Spring框架--AOP编程，JDBC支持

Posted 2020-08-23

2 手动实现AOP编程

AOP 面向切面的编程，

         AOP可以实现“业务代码”与“关注点代码”分离

// 保存一个用户
public void add(User user) { 
        Session session = null; 
        Transaction trans = null; 
        try { 
            session = HibernateSessionFactoryUtils.getSession();   // 【关注点代码】
            trans = session.beginTransaction();    // 【关注点代码】
             
            session.save(user);     // 核心业务代码
             
            trans.commit();     //…【关注点代码】

        } catch (Exception e) {     
            e.printStackTrace(); 
            if(trans != null){ 
                trans.rollback();   //..【关注点代码】

            } 
        } finally{ 
            HibernateSessionFactoryUtils.closeSession(session);   ////..【关注点代码】

        } 
   } 

 

分析总结：

         关注点代码，就是指重复执行的代码。

         业务代码与关注点代码分离，好处？

              关注点代码写一次即可；

              开发者只需要关注核心业务；

              运行时期，执行核心业务代码时候动态植入关注点代码； 【代理】

如何分离？

         过程式/对象式/代理模式分离

 

/**
 * 目标对象
 */
@Component   // 加入容器
public class UserDao implements IUserDao{

    @Override
    public void save() {
        System.out.println("-----核心业务：保存！！！------");
    }

}

 

使用动态代理方式，增强userdao，动态植入重复代码，这就是AOP编程的思想:

/**
 * 代理工厂
 */
public class ProxyFactory {
    
    // 目标对象
    private static Object target;
    private static Aop aop;

    // 生成代理对象的方法
    public static Object getProxyInstance(Object target_,Aop aop_){
        
        target = target_;
        aop = aop_;
        
        return Proxy.newProxyInstance(
                target.getClass().getClassLoader(), 
                target.getClass().getInterfaces(), 
                new InvocationHandler() {
                    
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args)
                            throws Throwable {
                        aop.begin();// 执行重复代码
                        
                        // 执行目标对象的方法
                        Object returnValue = method.invoke(target, args);
                        
                        aop.commite(); // 执行重复代码
                        return returnValue;
                    }
                });
    }
}

 

3. AOP编程

3.1 概述：

Aop，  aspect object programming  面向切面编程

         功能： 让关注点代码与业务代码分离！

关注点,

         重复代码就叫做关注点；

切面，

          关注点形成的类，就叫切面(类)！

          面向切面编程，就是指 对很多功能都有的重复的代码抽取，再在运行的时候往业务方法上动态植入“切面类代码”。

切入点，

         执行目标对象方法，动态植入切面代码。

         可以通过切入点表达式，指定拦截哪些类的哪些方法； 给指定的类在运行的时候植入切面类代码。

 

3.2 注解方式实现AOP编程

步骤：

1） 先引入aop相关jar文件           （aspectj  aop优秀组件）                                      

            spring-aop-3.2.5.RELEASE.jar   【spring3.2源码】

　　　　aopalliance.jar                           【spring2.5源码/lib/aopalliance】

　　　　aspectjweaver.jar                      【spring2.5源码/lib/aspectj】或【aspectj-1.8.2\lib】

　　　　aspectjrt.jar                             【spring2.5源码/lib/aspectj】或【aspectj-1.8.2\lib】

 

注意： 用到spring2.5版本的jar文件，如果用jdk1.7可能会有问题。

         需要升级aspectj组件，即使用aspectj-1.8.2版本中提供jar文件提供。

 

 

2） bean.xml中引入aop名称空间

 

 

3） 开启aop注解

 

4) 使用注解

　　@Aspect       指定一个类为切面类             

　　@Pointcut("execution(* cn.itcast.e_aop_anno.*.*(..))")  指定切入点表达式

　　@Before("pointCut_()")               前置通知: 目标方法之前执行

　　@After("pointCut_()")                 后置通知：目标方法之后执行（始终执行）

　　@AfterReturning("pointCut_()")   返回后通知： 执行方法结束前执行(异常不执行)

　　@AfterThrowing("pointCut_()")    异常通知:  出现异常时候执行

　　@Around("pointCut_()")              环绕通知： 环绕目标方法执行