Spring 的控制反转：把对象的创建、初始化、销毁等工作交给Spring 容器来做，有spring容器控制对象的生命周期
applicationContext.xml
beans --->spring 容器中的类
alias—>取别名
不管有继承关系（不管有几层）先把当前类加载到虚拟机中才能创建对象，而在加载过程中，静态代码块（static ）就一块执行了。所以
现在子类静态代码快赋值，在父类中（@before）接受并使用该值
无论两个类之间有什么继承关系，今天代码块比方法先执行。
--------------------------------------------------------------------------------------------------------------------------------------------------------
在默认情况下，Spring创建bean是单例模式，属性是共享的（线程安全问题）
bean scope属性--->singleton（单例,共享，默认）一般情况下，把数据存放在方法中的变量中，尽量别放在类的属性中\prototype(多例) 当一个bean是多例模式下，lazy-init为false或者default无效
init-method
* 该方法是由spring容器执行
* 在构造函数之后执行
* 如果在构造函数之后，在调用方法之前要做一些工作，可以在init方法中完成
destroy-method
* 如果该bean是单例，则在spring容器关闭或者销毁的时候，执行该方法
* 如果该bean是多例，则spring容器不负责销毁
说明：要想让spring容器控制bean的生命周期，那么该bean必须是单例
如果该bean是多例，该bean中还有资源，关闭资源的操作由程序员完成
在启动spring容器的时候，spring容器配置文件中的类就已经创建完成对象了
lazy-init
default false
true 在context.getBean的时候才要创建对象
* 优点
如果该bean中有大数据存在，则什么时候context.getBean,什么时候创建对象
可以防止数据过早的停留在内存中，做到了懒加载
* 缺点
如果spring配置文件中，该bean的配置有错误，那么在tomcat容器启动的时候，发现不了
false 在启动spring容器的时候创建对象
* 优点
如果在启动tomcat时要启动spring容器，
那么如果spring容器会错误，这个时候tomcat容器不会正常启动
* 缺点
如果存在大量的数据，会过早的停留在内存中
DI（依赖注入）：给属性赋值 person类中name;
eg、
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">
<bean id="person" class="cn.itcast.spring0909.di.xml.set.Person">
<!--
property就是代表属性
在spring中基本类型(包装类型和String)都可以用value来赋值
引用类型用ref赋值
-->
<property name="pid" value="5"></property>
<property name="pname" value="王二麻子"></property>
<property name="student">
<ref bean="student"/>
</property>
<property name="lists">
<list>
<value>list1</value>
<value>list2</value>
<ref bean="student"/>
</list>
</property>
<property name="sets">
<set>
<value>set1</value>
<value>set2</value>
<ref bean="student"/>
</set>
</property>
<property name="map">
<map>
<entry key="map1">
<value>map1</value>
</entry>
<entry key="map2">
<value>map2</value>
</entry>
<entry key="map3">
<ref bean="student"/>
</entry>
</map>
</property>
<property name="properties">
<props>
<prop key="prop1">
prop1
</prop>
</props>
</property>
</bean>
<bean id="student" class="cn.itcast.spring0909.di.xml.set.Student"></bean>
</beans>
构造函数：
<bean id="person" class="cn.itcast.spring0909.di.xml.constructor.Person">
<!--
构造函数的参数
index 第几个参数，下标从0开始
type 参数的类型
ref 如果类型是引用类型，赋值
value 如果类型是基本类型，赋值
说明：
只能指定一个构造函数
-->
<constructor-arg index="0" type="java.lang.String" value="干露露"></constructor-arg>
<constructor-arg index="1" ref="student"></constructor-arg>
</bean>
IOC和DI做了什么事情：
1、创建对象
2、为对象的属性赋值
意义在于：可以在一个类引用一个接口，而给接口赋值的工作交给spring容器来做，程序员只需在配置文件作相应的配置就好了，这样客户端就可以完全的面向接口的编程。
----------------------------------------------------------------------------------------------------------------------------------------------
annotation
@Resource注解
原理
* * 启动spring容器，并且加载配置文件
* * 会为student和person两个类创建对象
* * 当解析到<context:annotation-config></context:annotation-config>
* 会启动依赖注入的注解解析器
* * 会在纳入spring管理的bean的范围内查找看哪些bean的属性上有@Resource注解
* * 如果@Resource注解的name属性的值为"",则会把注解所在的属性的名称和spring容器中bean的id进行匹配
* 如果匹配成功，则把id对应的对象赋值给该属性，如果匹配不成功，则按照类型进行匹配,如果再匹配不成功，则报错
* * 如果@Resource注解的name属性的值不为"",会把name属性的值和spring容器中bean的id做匹配，如果匹配
* 成功，则赋值，如果匹配不成功 ，则直接报错
* 说明：
* 注解只能用于引用类型，如果一个类中有基本数据类型（long int String），并且基本类型使用Spring的形式赋值的，这个时候，该类必须用xml进行赋值（在javaweb中很少直接赋值，大多数都是从服务器获取值）
@component注解
原理
* * 启动spring容器，加载配置文件
* * spring容器解析到
* <context:component-scan base-package="cn.itcast.spring0909.scan"></context:component-scan>
* * spring容器会在指定的包及子包中查找类上是否有@Component
* * 如果@Component注解没有写任何属性
* @Component
* public class Person{
*
* }
* ==
* <bean id="person" class="..Person">
* 如果@Component("aa")
* @Component
* public class Person{
*
* }
* ==
* <bean id="aa" class="..Person">
* * 在纳入spring管理的bean的范围内查找@Resource注解
* * 执行@Resource注解的过程
* 说明：
* xml效率比较高，但是书写比较麻烦
* 注解效率比较低，书写比较简单
-------------------------------------------------------------------------------------------------------------------------------------
<!--
abstract
spring容器不会为该类创建对象
-->
<bean id="person" class="cn.itcast.spring0909.extend.Person" abstract="true">
<property name="name" value="王二麻子的哥"></property>
</bean>
--------------------------------------------------
<bean id="person" class="cn.itcast.spring0909.extend.Person" abstract="true">
<property name="name" value="王二麻子的哥"></property>
</bean>
<!--
parent
让子类拥有父类的属性的值
-->
<bean id="student" class="cn.itcast.spring0909.extend.Student" parent="person">
</bean>
代理模式、动态代理 （invoke）
package cn.itcast.salary.jdkproxy; import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
/**
* 1、把日志、安全性框架、权限导入进去
* 2、把目标类导入进去
* 3、上述两类通过构造函数赋值
* @author Administrator
*
*/
public class SalaryInterceptor implements InvocationHandler{ private Logger logger;
private Security security;
private Privilege privilege; private Object target; public SalaryInterceptor(Logger logger,Security security,Privilege privilege,Object target){
this.logger = logger;
this.security = security;
this.privilege = privilege;
this.target = target;
} @Override
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
// TODO Auto-generated method stub
System.out.println("aaaaaa");
this.logger.logging();
this.security.security();
if("admin".equals(this.privilege.getAccess())){
//调用目标类的目标方法
method.invoke(this.target, args);
}else{
System.out.println("您没有该权限");
}
System.out.println("bbbbbb");
return null;
} }
客户端
public void test(){
Logger logger = new Logger();
Privilege privilege = new Privilege();
privilege.setAccess("admin");
Security security = new Security();
SalaryManager target = new SalaryManagerImpl();
SalaryInterceptor interceptor = new SalaryInterceptor(logger, security, privilege, target);
/**
* 1、目标类的类加载器
* 2、目标类的所有的接口
* 3、拦截器
*/
SalaryManager proxy = (SalaryManager) Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), interceptor);
proxy.showSalary();//代理对象的代理方法
}
---------------------------------------------------------------------------------------------------------------
---------------------------------------------------------------------------------------------------------------------
AOP
说明：
* 切面
日志、安全性的框架、权限的检查等，总之和业务逻辑没有关系的都可以看做切面
* 通知
切面中的方法
* 切入点
只有符合切入点，才能把通知和目标方法结合在一起
* 连接点
客户端调用的方法
* 代理对象的方法=通知+目标方法
* aop:做到了代码块的重用
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop-2.5.xsd">
<!--
1、引入AOP的命名空间
2、目标类
3、切面
4、拦截器 由spring内部实现
5、aop的配置
-->
<bean id="personDao" class="cn.itcast.spring0909.aop.xml.PersonDaoImpl"></bean>
<bean id="transaction" class="cn.itcast.spring0909.aop.xml.Transaction"></bean>
<!--
aop的配置
-->
<aop:config>
<!--
切入点表达式
expression
确定哪个类可以生成代理对象
id 唯一标识
-->
<aop:pointcut expression="execution(* cn.itcast.spring0909.aop.xml.PersonDaoImpl.*(..))" id="perform"/>
<!--
切面
-->
<aop:aspect ref="transaction">
<!--
前置通知
-->
<aop:before method="beginTransaction" pointcut-ref="perform"/>
<aop:after-returning method="commit" pointcut-ref="perform"/>
</aop:aspect>
</aop:config>
</beans>
------------------------------------------------------------------------------------------------------
<aop:config>
<!--
切入点表达式
expression
确定哪个类可以生成代理对象
id 唯一标识
-->
<aop:pointcut expression="execution(* cn.itcast.spring0909.aop.xml.PersonDaoImpl.*(..))" id="perform"/>
<!--
切面
-->
<aop:aspect ref="transaction">
<!--
前置通知
* 在目标方法执行之前
*
-->
<!--
<aop:before method="beginTransaction" pointcut-ref="perform"/>
-->
<!--
后置通知
* 在目标方法执行之后
* 可以根据returning获取目标方法的返回值
* 如果目标方法遇到异常，该通知不执行
-->
<!--
<aop:after-returning method="commit" pointcut-ref="perform" returning="val"/>
-->
<!--
前置通知和后置通知只能在目标方法文中添加内容，但是控制不了目标方法的执行
-->
<!--
最终通知
* 在目标方法执行之后
* 无论目标方法是否遇到异常，都执行
* 经常做一些关闭资源
-->
<!--
<aop:after method="finallyMethod" pointcut-ref="perform"/>
-->
<!--
异常通知
目的就是为了获取目标方法抛出的异常
-->
<aop:after-throwing method="exceptionMethod" throwing="ex" pointcut-ref="perform"/>
<!--
环绕通知
能控制目标方法的执行
-->
<aop:around method="aroundMethod" pointcut-ref="perform"/>
</aop:aspect>
</aop:config>
AOP总结：
* 原理
* * 加载配置文件，启动spring容器
* * spring容器为bean创建对象
* * 解析aop的配置，会解析切入点表达式
* * 看纳入spring管理的那个类和切入点表达式匹配，如果匹配则会为该类创建代理对象
* * 代理对象的方法体的形成就是目标方法+通知
* * 客户端在context.getBean时，如果该bean有代理对象，则返回代理对象，如果没有代理对象则返回原来的对象
* 说明：
* 如果目标类实现了接口，则spring容器会采用jdkproxy,如果目标类没有实现接口，则spring容器会采用
* cglibproxy
---------------------------------------------------------------------------------------------------------------------------------------------
Struts2
问题：
* action是单例还是多例？怎么样证明？
Action是多例的，在构造函数中输出一句话，如果请求好几次，只输出一次，单例
如果请求很多次，输出很多次，多例
* struts2有三个类
ActionContext
ServletActionContext 建立struts2与servlet的通信的桥梁
ActionInvocation struts2总的上下文
* struts2的数据都在值栈中，怎么样保证数据的安全性？值栈的生命周期是什么？
因为ValueStack在ActionContext中，而ActionContext在ThreadLoad中，所以可以保证数据的安全性
值栈的生命周期是一次请求，当前的action,actioncontext,valuestack的生命周期是一致的
--------------------------------------------------------------------------------------------------------
