Spring学习记录(二)
1.Spring中的AOP思想
aop思想：横向重复，纵向抽取。
AOP(Aspect-OrientedProgramming,面向切面编程)，AOP包括切面(Aspect)，通知(Advice)，连接点(joinpoint)，
实现方式就是通过目标对象的代理在连接点前后加入通知，完成统一的切面操作。
这个思想在filter过滤器,拦截器,动态代理中就已经使用过，例如：
(1) 在解决乱码的问题上
(2) 在动态代理上，管理事务：(Proxy.newProxyInstance(Classloader cloader,Interface[] arr, InvocationHandle h))
(3) 拦截器中在参数赋值上，一般每个action的参数赋值，都需要有这个参数，但是有拦截器可以完成把参数赋值到action中，或者校验登录
2.AOP实现原理
Spring能够为容器中管理的对象生成动态代理对象。
以前未使用Spring时，要使用动态代理，我们需要自己调用这个方法：
Proxy.newProxyInstance(Classloader cloader,Interface[] arr, InvocationHandle h)，生成代理对象。
使用Spring后，能帮助我们生成代理对象(只需要在配置文件中配置，或者注解配置即可)，那么为什么与AOP思想有关呢？
比如上面例子中的管理事务，使用动态代理对象在进行事务的管理，只需要写一次代码就能够完成，但是需要自己手写代理对象，而用Spring可以自动的生成Service的代理对象，所以称为Spring的AOP思想
所以根据上面的铺垫，AOP的实现原理可以说就是动态代理，或者cglib代理，还有静态织入(引入特定的语法创建“方面”，从而是的编译器可以在编译期间织入有关“方面”的代码)。 ()
(1) 动态代理(优先)：被代理对象必须要实现接口，才能产生代理对象，如果没有借口将不能使用动态代理技术
(2) cglib代理(没有接口)：第三方代理技术，cglib代理可以对任何类生成代理，代理的原理是对目标对象进行继承代理。如果目标对象被final修饰，那么该类无法被cglib代理。
使用动态代理的一个代码示例：
首先创建接口，以及实现类
/** * Created by YuKai Fan on 2018/9/27. */ public interface UserService { void save(); void delete(); void update(); void find(); }
/** * Created by YuKai Fan on 2018/9/27. */ public class UserServiceImpl implements UserService { //这些方法都是业务逻辑，一般来说在进行业务方法进行事务管理 @Override public void save() { //如果不使用动态代理每个方法都需要进行打开事务，提交事务的操作 //System.out.println("打开事务"); System.out.println("保存用户"); //System.out.println("提交事务"); } @Override public void delete() { System.out.println("删除用户"); } @Override public void update() { System.out.println("修改用户"); } @Override public void find() { System.out.println("查找用户"); } }
再创建一个代理工厂，来生成上面接口的一个代理对象
/** * 用户service层的代理工厂 * Created by YuKai Fan on 2018/9/27. */ public class UserServiceProxyFactory implements InvocationHandler{ private UserService us; public UserServiceProxyFactory(UserService us) { super(); this.us = us; } public UserService getUserServiceProxy() { //生成动态代理 UserService usProxy = (UserService) Proxy.newProxyInstance(UserServiceProxyFactory.class.getClassLoader(), UserServiceImpl.class.getInterfaces(), this);//第三个参数，必须要实现InvocationHandler接口 return usProxy; } @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { //使用动态代理，只需要写一次即可 System.out.println("打开事务"); Object invoke = method.invoke(us, args);//方法的执行，需要方法所存在的对象，所以需要有实例。创建一个构造方法，来传递一个执行方法所对应的实例对象 System.out.println("提交事务"); return invoke; } }
测试：
/** * Created by YuKai Fan on 2018/9/27. */ public class Demo { public static void main(String[] args) { UserService us = new UserServiceImpl(); UserServiceProxyFactory factory = new UserServiceProxyFactory(us); UserService usProxy = factory.getUserServiceProxy(); usProxy.save(); } }
测试结果：代理对象每次在执行业务逻辑代码时，都需要执行事务的操作，因为在代理对象在执行方法时，先进行了事务操作。
使用cglib代理的一个代码示例(了解)：
创建代理工厂
/** * cglib代理(了解) * Created by YuKai Fan on 2018/9/27. */ public class UserServiceProxyFactory2 implements MethodInterceptor{ public UserService getUserServiceProxy() { //生成代理对象 Enhancer en = new Enhancer(); en.setSuperclass(UserServiceImpl.class);//设置对谁进行代理 en.setCallback(this);//代理要做什么 UserService us = (UserService) en.create();//创建代理对象 return us; } @Override //参数解析：methodProxy方法代理，method被代理的方法，o代理的原始对象，arg运行期的参数 public Object intercept(Object o, Method method, Object[] arg, MethodProxy methodProxy) throws Throwable { //打开事务 System.out.println("打开事务"); //调用原有方法 Object returnValue = methodProxy.invokeSuper(o, arg); //提交事务 System.out.println("提交事务"); return returnValue; } }
测试：
/** * Created by YuKai Fan on 2018/9/27. */ public class Demo { public static void main(String[] args) { UserService us = new UserServiceImpl(); UserServiceProxyFactory factory = new UserServiceProxyFactory(us); UserServiceProxyFactory2 factory2 = new UserServiceProxyFactory2();//cglib代理 UserService usProxy = factory.getUserServiceProxy(); UserService usProxy2 = factory2.getUserServiceProxy();//cglib生成的代理对象 usProxy.save(); usProxy2.delete(); //判断代理对象是否输入被代理对象类型 //只是代理对象与被代理对象实现了相同的接口，但是没有继承关系 System.out.println(usProxy instanceof UserServiceImpl);//false //而cglib代理，是与被代理对象进行继承，所以类型相同 System.out.println(usProxy2 instanceof UserServiceImpl);//true } }
测试结果：
3.AOP名词解析
以上面的源代码为例
1.Joinpoint(连接点)：目标对象中，所有可以增强的方法。(联系上面的例子，就是指那些实现接口的实现类的所有业务方法，即save(),delete(),update(),find())
2.Pointcut(切入点)：目标对象，已经增强的方法。(创建代理对象后，进行增强的方法。比如在执行方法前开始事务，执行方法后提交事务。在上面的例子中，由于没有指定使用哪一个的特定方法，所以那四个方法全是切入点)
3.Advice(通知/增强)：增强的代码。(根据上面的例子，我们需要在执行目标方法前后，打开事务和提交事务，所以那些打开事务，提交事务的代码，就叫做通知)
4.Target(目标对象)：被代理对象(实现类，上面的UserServiceImpl)
5.weaving(织入)：将通知应用到切入点的过程(将打开事务和提交事务，应用到目标方法的过程)
6.Proxy*代理)：将通知应用到目标对象之后，形成代理对象
7.aspect(切面)：切入点+通知
下面是Spring AOP的应用示例：
步骤：
(1) 导包
(2) 准备目标对象
/** 目标对象 * Created by YuKai Fan on 2018/9/27. */ public class UserServiceImpl implements UserService { //这些方法都是业务逻辑，一般来说在进行业务方法进行事务管理 @Override public void save() { //如果不使用动态代理每个方法都需要进行打开事务，提交事务的操作 //System.out.println("打开事务"); System.out.println("保存用户"); //System.out.println("提交事务"); } @Override public void delete() { System.out.println("删除用户"); } @Override public void update() { System.out.println("修改用户"); } @Override public void find() { System.out.println("查找用户"); } }
(3) 准备通知
/** * aop的通知类 * Created by YuKai Fan on 2018/9/28. */ public class MyAdvice { //前置通知：目标方法运行前调用 //后置通知(如果出现异常不会调用)：在目标方法之后调用 //环绕通知：在目标方法之前和之后都调用 //异常拦截通知：如果出现异常，就会调用 //后置通知(无论是否出现异常都会通知)：在目标方法之后调用 //前置通知 public void before() { System.out.println("这是前置通知！！"); } //后置通知(如果出现异常不会调用) public void afterReturning() { System.out.println("这是后置通知！！(如果出现异常不会调用)"); } //环绕通知，必须要手动的调用目标方法，所以需要有一个ProceedingJoinPoint对象 public Object around(ProceedingJoinPoint pjp) throws Throwable {
System.out.println("这是环绕通知之前！！"); Object proceed = pjp.proceed();//调用目标方法， System.out.println("这是环绕通知之后！！"); return proceed; } //异常通知 public void afterException() { System.out.println("出事了，出现异常了！！"); } //后置通知(无论是否出现异常都会通知) public void after() { System.out.println("这是后置通知(无论是否出现异常都会通知)！！"); } }
(4) 配置进行织入，将通知应用到目标对象中
applicationContext.xml
<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.2.xsd "> <!-- 准备工作：导入aop(约束)命名空间 --> <!-- 1.配置目标对象 --> <bean name="userService" class="com.javaweb.service.UserServiceImpl"></bean> <!-- 2.配置通知对象 --> <bean name="myAdvice" class="com.javaweb.aspect.MyAdvice"></bean> <!-- 配置将通知织入目标对象 --> <aop:config> <!-- 配置切入点 public void com.javaweb.service.UserServiceImpl.save()，只针对save方法进行织入 void com.javaweb.service.UserServiceImpl.save() public可以省略，默认就是public * com.javaweb.service.UserServiceImpl.save() 对返回值不做要求 * com.javaweb.service.UserServiceImpl.*() 对目标类下的所有空参方法织入 * com.javaweb.service.UserServiceImpl.*(..) 对方法的参数不做任何要求 * com.javaweb.service.*ServiceImpl.*(..) 可以对任何在service包下以ServiceImpl结尾的类进行织入 * com.javaweb.service..*ServiceImpl.*(..) 可以对service下的子包也进行织入 --> <aop:pointcut id="pc" expression="execution(* com.javaweb.service.*ServiceImpl.*(..))" /> <aop:aspect ref="myAdvice"> <!-- 指定名为before方法作为前置通知 --> <aop:before method="before" pointcut-ref="pc"/> <!-- 后置(无论是否出现异常) --> <aop:after method="after" pointcut-ref="pc"/> <!-- 环绕 --> <aop:around method="around" pointcut-ref="pc"/> <!-- 异常 --> <aop:after-throwing method="afterException" pointcut-ref="pc"/> <!-- 后置(出现异常不会调用) --> <aop:after-returning method="afterReturning" pointcut-ref="pc" /> </aop:aspect> </aop:config> </beans>
demo测试：
/** * Created by YuKai Fan on 2018/9/28. */ @ContextConfiguration("classpath:com/javaweb/springAOP/applicationContext.xml") public class Demo { @Resource(name="userService")//已经获取到代理对象 private UserService us; @Test public void fun() { us.save(); } }
测试结果：
