Spring 教程（二）

时间  2019-11-13
标签 spring 教程 栏目 Spring 繁體版
原文   原文链接
1、Spring AOP介绍
开发其实就是在不断的重构，抽象重复代码，而后进行封装。从最原始的模块化编程到面向对象编程，代码的封装愈来愈整齐清晰，可是依然存在重复的代码，而这些重复代码几乎都是与业务逻辑无关的系统逻辑代码。好比在数据操做类中的插入、更新、删除数据等方法中都存在数据库事务的处理，重要业务逻辑方法中都有日志记录的逻辑等等。每一个应用系统都存在着这种系统级的重复逻辑代码，而咱们并无更好的方法去将这些代码抽象出来并进行管理。然而AOP的出现弥补了这一缺陷，AOP能够在不改变原有业务逻辑代码的状况下对原有业务进行横切拦截，处理那些重复的系统逻辑。
 
与Ioc容器同样，AOP也是Spring的核心模块之一。AOP是Aspect-Oriented Programming的简称，如今一般称为面向切面编程。咱们学了OOP，面向对象编程，而AOP并不是是OOP的替代技术，它只是OOP的一个有益补充。
 
须要指出的是AOP的应用场合是受限的，它通常只适合于那些具备横切逻辑的应用场合：如性能监测、访问控制、事务管理以及日志记录，它并不适合处理具体的业务逻辑，分散处理业务逻辑会使得逻辑混乱、增长维护成本。
 
 
2、如何使用Spring AOP
下面以对用户操做类UserDao的AOP拦截演示Spring AOP的使用。
一、建立Java项目，添加Spring AOP依赖支持
aopalliance-1.0.jar
commons-logging-1.1.1.jar
spring-aop-3.2.0.RELEASE.jar
spring-beans-3.2.0.RELEASE.jar
spring-context-3.2.0.RELEASE.jar
spring-core-3.2.0.RELEASE.jar
spring-expression-3.2.0.RELEASE.jar
 
二、添加User及UserDao类
User类：
  1. public class User {  
  2.     private Integer id;  
  3.     private String name;  
  4. }  
UserDao类：
  1. public class UserDao {  
  2.     public void save(User user){  
  3.         System.out.println("save user....");  
  4.     }  
  5.       
  6.     public void delete(int id){  
  7.         System.out.println("delete user....");  
  8.     }  
  9.       
  10.     public void update(User user) {  
  11.         System.out.println("update user ....");  
  12.     }  
  13.       
  14.     public User query(String name) {  
  15.         System.out.println("getUser ....");  
  16.         return new User();  
  17.     }  
  18. }  
三、添加AOP拦截处理
AOP前置通知：
  1. public class UserBeforeAdvice implements MethodBeforeAdvice {      
  2.     public void before(Method method, Object[] args, Object target) {  
  3.         System.out.println("调用方法："+method.getName() + "()前拦截处理");  
  4.     }     
  5. }  
AOP后置通知：
  1. public class UserAfterAdvice implements AfterReturningAdvice {  
  2.     public void afterReturning(Object returnValue, Method method, Object[] args, Object target) {  
  3.         System.out.println("方法："+method.getName() + "()返回后拦截处理");  
  4.     }  
  5. }  
AOP环绕通知：
  1. public class UserAroundAdvice implements MethodInterceptor {  
  2.     public Object invoke(MethodInvocation invocation) throws Throwable {  
  3.         System.out.println("调用方法："+invocation.getMethod().getName() + "()前拦截处理");  
  4.         Object o = invocation.proceed();  
  5.         System.out.println("调用方法："+invocation.getMethod().getName() + "()后拦截处理");  
  6.         return o;  
  7.     }  
  8. }  
四、添加Spring配置文件applicationContext.xml
  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <beans xmlns="http://www.springframework.org/schema/beans"  
  3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
  4.        xsi:schemaLocation="http://www.springframework.org/schema/beans   
  5.            http://www.springframework.org/schema/beans/spring-beans-3.2.xsd">  
  6.     <bean id="userDaoTarget" class="com.boya.spring.dao.UserDao" />  
  7.     <bean id="userBeforeAdvice" class="com.boya.spring.aop.UserBeforeAdvice" />  
  8.     <bean id="userAfterAdvice" class="com.boya.spring.aop.UserAfterAdvice" />  
  9.     <bean id="userAroundAdvice" class="com.boya.spring.aop.UserAroundAdvice" />  
  10.     <bean id="userDao" class="org.springframework.aop.framework.ProxyFactoryBean">  
  11.         <property name="interceptorNames">  
  12.             <list><value>userAroundAdvice</value></list>  
  13.         </property>  
  14.         <property name="target" ref="userDaoTarget"></property>  
  15.     </bean>  
  16. </beans>  
五、测试AOP
  1. public static void main(String[] args) {  
  2.     ApplicationContext context = new ClassPathXmlApplicationContext("classpath:applicationContext.xml");  
  3.     UserDao userDao = context.getBean("userDao", UserDao.class);  
  4.     userDao.save(new User());  
  5. }  
输出结果：
调用方法：save()前拦截处理
save user....
调用方法：save()后拦截处理
 
回过头来再看刚才的示例。
一、首先，原来的业务逻辑代码不变
    再也不关心重复的系统逻辑代码
二、编写AOP切面处理逻辑
    把原业务逻辑中的重复代码抽象出来，封装入切面代码中，如上面示例的三种Advice通知封装不一样的系统处理逻辑。
    前置通知：实现MethodBeforeAdvice 接口，在调用业务方法前调用该接口
    后置通知：实现AfterReturningAdvice 接口，在业务方法返回后调用该接口，在该接口中能够查看返回值（但不能修改返回值）
    环绕通知：实现MethodInterceptor 接口，在该接口中invocation.proceed();这个方法会调用真实对象的方法
三、使用Spring配置文件将业务逻辑和AOP切面逻辑进行组装
    AOP代理Bean类型须要设置为org.springframework.aop.framework.ProxyFactoryBean
    必须设置代理目标（target属性设置）和通知类型（interceptorNames属性设置）
    代理目标并不是必须实现接口，做为POJO被代理时，会对目标全部方法进行拦截
 
3、AOP实现原理
Spring AOP是基于Java反射和动态代理实现的。在讲解动态代理以前，咱们先回顾一下代理模式。
代理模式，就是为某一对象提供一个代理，经过代理操做该对象的方法。一般状况下，真实对象和代理对象须要实现相同的接口，在代理对象中保存真实对象的引用，以此来控制操做真实对象。
 
咱们以班长代理老师签到来演示代理模式。
建立签到接口：
  1. public interface SignInterface {  
  2.     public Object sign(String nameList);  
  3. }  
建立真实对象，Teacher类：
  1. public   class  Teacher  implements  SignInterface {  
  2.      public  Object sign(String nameList) {  
  3.         System. out .println( "Teacher sign..." );  
  4.          return   new  Object();  
  5.     }  
  6. }  
建立代理对象，Leader类：
  1. public class Leader implements SignInterface {  
  2.     private Teacher teacher;  
  3.     public Object sign(String nameList) {  
  4.         if (teacher == null) {  
  5.             teacher = new Teacher();  
  6.         }  
  7.         Object o = teacher.sign(nameList);  
  8.         return o;  
  9.     }  
  10. }  
测试代理：
  1. public static void main(String[] args) {  
  2.     SignInterface s = new Leader();  
  3.     s.sign("names");  
  4. }  
以上就是一个代理模式的例子，代理类在编译时就已经被建立了，而动态代理是在运行时动态建立代理类来实现代理模式。以下代码：
  1. public class ProxyObject implements InvocationHandler {  
  2.     private Object proxy_obj;  
  3.     ProxyObject(Object obj) {  
  4.         this.proxy_obj = obj;  
  5.     }  
  6.     public static Object getProxy(Object obj) {  
  7.         Class cls = obj.getClass();  
  8.         // 经过Proxy类的newProxyInstance方法来返回代理对象  
  9.         return Proxy.newProxyInstance(cls.getClassLoader(), cls.getInterfaces(), new ProxyObject(obj));  
  10.     }  
  11.     /** 
  12.      * 实现InvocationHandler接口的invoke 
  13.      */  
  14.     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {  
  15.         System.out.println("调用方法:" + method + "()以前拦截处理");  
  16.         if (args != null) {  
  17.             System.out.println("方法有" + args.length + "个参数");  
  18.             for (int i = 0; i < args.length; i++) {  
  19.                 System.out.println(args[i]);  
  20.             }  
  21.         }  
  22.         // 利用反射机制动态调用真实对象的方法  
  23.         Object o = method.invoke(proxy_obj, args);  
  24.         System.out.println("调用方法:" + method + "()以后拦截处理");  
  25.         return o;  
  26.     }  
  27.     // 测试代码  
  28.     public static void main(String agr[]) {  
  29.         SignInterface si = (SignInterface) getProxy(new Teacher());  
  30.         si.sign("names");  
  31.     }  
  32. }  
以上就是使用JDK的Proxy实现的动态代理，不过JDK的动态代理实现只支持针对接口的动态代理实现。Spring AOP实现默认也是动态代理方式，不过，Spring AOP支持CGLib Proxy的实现方式，能够针对POJO进行动态代理，实现AOP拦截。
 
咱们来看一下CGLib实现的一个简单AOP拦截
建立业务POJO：
  1. public class CGLibTeacher {  
  2.     public Object sign(String nameList) {  
  3.         System.out.println("Teacher sign...");  
  4.         return new Object();  
  5.     }  
  6. }  
建立AOP拦截：
  1. public class CGLibAop implements MethodInterceptor {  
  2.         public Object intercept(Object arg0, Method arg1, Object[] arg2,     
  3.                 MethodProxy arg3) throws Throwable {     
  4.             System.out.println("before...");  
  5.             Object o = arg3.invokeSuper(arg0, arg2);  
  6.             System.out.println("after...");  
  7.             return o;  
  8.         }     
  9. }  
CGLib代理对象建立及测试：
  1. public class CGLibProxy {  
  2.     public static CGLibTeacher create(CGLibAop aop){  
  3.         Enhancer en = new Enhancer();     
  4.         //进行代理    
  5.         en.setSuperclass(CGLibTeacher.class);     
  6.         en.setCallback(aop);     
  7.         //生成代理实例    
  8.         return (CGLibTeacher)en.create();     
  9.     }  
  10.       
  11.     public static void main(String[] args) {  
  12.         CGLibTeacher t = CGLibProxy.create(new CGLibAop());  
  13.         t.sign("names");  
  14.     }  
  15. }  
从CGLib的代理对象建立中能够看到，代理对象须要设置代理目标以及AOP拦截实现，和Spring AOP的实现很是相似。
相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程