Annotation复习:
1,Annotation:作为类型的元数据;
1,给类型加标记;
2,annotation可以添加各种类型的属性;
2,Annotation的上的标记:
1）,target:标签可以加在什么类型上的;
1）,TYPE:所有类和接口;
2）,METHOD:方法;
3）,FIELD:字段上面;
4）,PARAMETER:方法的参数上面;
5）,CONSTRUCTOR:构造器方法;
2）,retention:把标签保留到什么时候;
1）,CLASS:保留到字节码;
2）,SOURCE:保留到代码;
3）,RUNTIME:保留到运行时;
3,标签一般需要三方参与:
1）,标签类型;
2）,打标签的目标类型;
3）,解析程序;
4），注解的参数：
1），注解中属性的添加方式；
2），注解中属性的默认值；
3），getAnnotation方法的使用；
Spring的注解使用;
DI注解的使用:
1,使用DI注解,在spring的配置文件里面还是需要配置bean本身;
2,@Autowired
1）,autowired标签可以把需要的对象自动的注入到目标对象中;
2）,autowired标签可以放在字段上,也可以放在setter方法上面;
3）,autowired的执行流程:
1）,加载和解析XML文件;
2）,实例化所有的bean,并且方到spring的容器当中;
3）,解析对象的类型,如果对象类型的某些字段或者setter方法上面有@Autowired标签,
1）,在容器中找到对应的对象;
2）,把找到的对象设置到字段或者setter方法中;
4）,怎么找对象?
1）,首先按照类型找;
2）,如果没有找到;系统报错(默认情况下,autowired标签有一个@Required标签的作用)
3）,如果找到多个,按照字段或者属性的名字,再用名字+类型去找;
4）,如果1,3都没有找到,报错;
5）,可以通过设置autowired的required=false让这个属性(字段)可以没有值;
6）,可以通过在字段或者setter方法上添加@Qualifier来规定我要注入的bean的名字;
7）,可以在Spring的主要对象上面添加@Autowired,让spring自动注入;
8）,所以,我们的spring的测试类,可以直接引用需要测试的目标对象就可以了;
3,@Resource
1）,也可以通过resource标签来自动注入;
2）,怎么找对象?
1）,首先按照字段或者属性的名字找;
2）,如果找不到,报错(resource关联的对象必须存在)
3）,如果按照名字找不到,再按照类型来找;
4）,可以通过resource的name属性来指定一个bean注入;如果一旦设置了resource的name属性,就只能按照名字找了;
5）,因为resource是javax的标签,所以resource不能注入spring中关键的对象;
选择:
1,Resource是JavaEE的规范,但是缺少spring对autowired标签的一些加强;
2,一般我们选择使用@Autowired标签;
使用IoC注解:
1,在配置文件中告诉spring去哪里扫描实例对象;
<!-- 如果要使用IOC的注解,一定要配置一个context:component-scan, base-package表示,让Spring去扫描包及其子包下的类(是否带有IOC注解) 如果要配置多个包,包之间用逗号隔开 --> <context:component-scan base-package="com.rk1632._03_annotation_ioc"/>
2,在类型上面添加anntation:
1）,@Component:一般我们写在工具类上面;
2）,@Service:一般我们写在服务对象上;
3）,@Repository:一般写在DAO上面;
4）,@Controller:一般写在Action上面;并且在SpringMVC中,Controller就在标示一个Controller对象;
3,这四个标签对于spring来说,作用相同,主要是给程序员看的;
<bean id="" class="" factory-method="" factory-bean="" init-method="" destory-method="" scope=""/>
1,id:所有的四个标签都支持value值,这个值就是id的名字;
2,class:不用写了;
3,factory-method和factory-bean就没有对应的标签了;如果有这种需要,直接配置到XML里面(XML和Annocation是可以混用的)
4,init-method:使用@PostConstruct直接放在init方法上面;注意:initmethod一定是在DI（依赖注入）之后执行的;
5,destory-method:使用@PreDestroy直接放在destory方法上面;
6,scope,在类上面添加@Scope("prototype");
代理模式
提出问题:
问题:事务是开在dao上面的,所以如果在service中调用多个dao的方法,如果在这些方法执行过程中报错,事务没法回滚
对于我们的应用,事务都应该开在service的方法上面
解决办法:
1,sessionFactory.getCurrentSession:得到当前线程中的session;
2,把session的开启和事务的开启,事务的提交从dao中移到service方法中
存在一个事务跨层的问题，但是如果直接把事务管理的代码写在service中，会造成service代码污染，最好的方式就是把事务的代码从service中抽取出来，使用代理模式，再加到目标代码中：
静态代理：
public class EmployeeServiceImpl implements IEmployeeService { public void save(Employee e) { System.out.println("save Employee"); } public void update(Employee e) { System.out.println("update Employee"); } }
public class EmployeeTranscationServiceImpl implements IEmployeeService { private IEmployeeService target; public EmployeeTranscationServiceImpl(IEmployeeService service){ this.target = service; } @Override public void save(Employee e) { System.out.println("sessionFactory.getCurrentSession"); System.out.println("session.getTranscation().begin()"); target.save(e); System.out.println("session.getTranscation().commit()"); } @Override public void update(Employee e) { System.out.println("sessionFactory.getCurrentSession"); System.out.println("session.getTranscation().begin()"); target.update(e); System.out.println("session.getTranscation().commit()"); } }
静态代理分析:
静态代理分析:
1,静态代理确实处理了代码污染的问题;
问题:
1,重复的代码仍然分散在了各个方法中;
2,需要为每一个真实对象写一个代理对象;
Struts中的拦截器：
动态代理
1,有接口的对象的动态代理
1）,JDK中提供了针对有接口对象的动态代理实现方式;
2,没有接口的对象的动态代理
1）,使用继承的方式完成动态代理;javassist/cglib
1,客户端调用save方法,执行被InvocationHanalder拦截;
2,在invoke方法中执行添加的额外的逻辑;
3,调用m.invoke(target,args)执行到了真实的目标对象上的对应方法;
4,真实对象返回执行结果到InvocationHandler里面;
5,执行完成其他逻辑,把结果返回给客户端;
使用JDK的动态代理流程:
1,使用JDK的动态代理,必须要保证代理的真实对象是有接口的;
/** * proxy:代理出来的对象 * method:这次调用的方法 * args:这次调用方法传入的参数 */ public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { }
2,需要实现一个InvocationHandler,并实现invoke方法（如上）;
0）,需要给InvocationHanlder的实现类提供真实对象;
1）,在invoke方法中执行自己的额外添加的业务逻辑;
2）,在编写完额外逻辑之后,调用method.invoke(target,args)执行真实对象上的对应方法;
3）,得到真实方法执行的结果;
4）,处理结果,并把结果返回给客户端;
//Proxy:专门用来生产代理类的对象 //newProxyInstance:需要三个参数 //1,ClassLoader():专门用来加载类的 //2,interfaces:需要接口的数组,这个接口就是我们目标对象实现的接口 //3,处理动态代理的类的对象 IEmployeeService service = (IEmployeeService)Proxy.newProxyInstance(service.getClass().getClassLoader(), new Class[]{IEmployeeService.class}, new TranscationInvocationHandler(service,txManager));
3,在客户端调用Proxy.newProxyInstance方法（如上）:
1）,需要传入目标对象的classloader;
2）,需要传入目标对象的接口类型;
3）,需要传入一个自定义的InvocationHandler的实例;
使用CGLIB完成没有接口的对象的动态代理
public class LogInvocationHandler implements InvocationHandler { private Object target; public LogInvocationHandler(Object target){ this.target = target; } @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { System.out.println("操作日志:操作时间:"+new Date()+", 当前调用的方法:"+method.getName()+", 传入的参数:"+Arrays.toString(args)); return method.invoke(target, args); } }
@Test public void test() throws Exception { SomeBean bean = new SomeBean(); //增强器 Enhancer enhancer = new Enhancer(); //设置目标对象的ClassLoader enhancer.setClassLoader(bean.getClass().getClassLoader()); //设置这个动态代理的父类 enhancer.setSuperclass(SomeBean.class); //设置要传入的拦截器 enhancer.setCallback(new LogInvocationHandler(bean)); //使用create方法创建代理对象 SomeBean o = (SomeBean) enhancer.create(); o.print1(); }
小结:
1,动态代理处理:重复的代码仍然分散在了各个方法中这个问题;
2,动态代理需要调用代码为每一个类去创建动态代理对象;
3,动态代理最小的单位就是一个类;
4,如果只想处理一个类型中的某些方法,在invoke方法中根据当前执行的方法名称去做判断就可以了;
Spring的AOP:
AOP就是一种更高级的动态代理的使用;
Aspect Oritention Programming(面向切面编程)
切入点:要加入业务逻辑的点(在哪些类的哪些方法上面;)
通知:通知包含两个方面,1,代表方法的执行时间,2,在这个时间上面要做什么事情;
切面:一个切入点+一个通知=一个切面(在什么地方,在什么时候,做什么事情);
织入:把一个切面应用到真实对象上面的过程,就叫做织入;
在Java中,没有语言能够准确的描述切入点;所以,有一个AspectJ,这是一种语言,提供了用于描述切入点的语言;
使用Spring的AOP:
1,使用XML的配置方式;
2,使用Annotation的配置方式;
定义切入点的表达式
如果可以是任意的值,使用*就可以了;
定义切入点表达式的例子如下：
aop包中,所有的service的所有的方法;
execution(* com._520it.spring.day2.aop.*Service.*(..));
day2中所有service的save方法;
execution(* com._520it.spring.day2..*Service.save(..))
<!-- 配置AOP --> <aop:config> <!-- 配置一个切入点 expression:这个切入点的表达式 id:这个切入点的名称 --> <aop:pointcut expression="execution(* com.rk1632._08_aop.*Service.*(..))" id="pc"/> <!-- 配置一个切面 ref:代表在这个切面的定义中,所有的做什么事情,都是由txManager这个对象的方法提供的 --> <aop:aspect ref="txManager"> <!-- before代表方法执行之前 --> <aop:before method="begin" pointcut-ref="pc"/> <!-- after-returning代表方法正常执行之后 --> <aop:after-returning method="commit" pointcut-ref="pc"/> <!-- after-throwing代表方法抛出异常的时候 --> <aop:after-throwing method="rollback" pointcut-ref="pc"/> </aop:aspect> </aop:config>
Spring中AOP的通知类型:
aop:before:前置通知;
aop:after-returning:后置通知;
aop:after:最终通知;
aop:after-throwing:异常通知;
aop:around:环绕通知;
小结:
1,准备了真实的对象,准备一个类,这个类里面的方法用来提供通知里面的做什么;
2,这两个类都要配置到Spring容器中;
3,配置springAOP
1,引入aop命名空间;
<aop:config>
<aop:point-cut expression="" id="" />
<aop:aspect ref="">
<aop:before method="" pointcut-ref="">
<aop:after-returning method="" pointcut-ref="">
<aop:after-throwing method="" pointcut-ref="">
</aop:aspect>
</aop:config>
4,我们在客户端还是直接注入的是在spring里面配置的真实对象;
实际上,spring在为这些对象创建好代理对象之后,会使用这些创建好的代理对象去替换容器中的原始对象;
SpringAOP的执行流程:
1，解析xml；
2，实例化所有的bean；
3，解析aop:config；
1），解析aop：aspect，得到aspect引用的对象；txManager
2），解析aop:aspect里面的每一个切面；
1），得到该aspect对应的pointcut-ref；
2），得到pointcut-ref对应的pointcut的表达式；
3），使用表达式中用于匹配类型的表达式；
4），使用该表达式去和spring里面配置的所有的bean的类型进行匹配；
1），如果匹配不上，不管；
2），如果匹配上了，该对象作为spring动态代理的目标对象；
1），如果该对象实现了接口，使用JDK的动态代理包装；
2），如果该对象没有实现接口，使用cglib包装；
3），得到配置的拦截时机+逻辑提供类（txManager）的对应方法（从method解析）+pointcut表达式中方法的匹配模式创建一个拦截器
4），在把该拦截器使用对应的动态代理机制代理成代理对象；
5），替换spring容器中的对应bean的实例；