Spring（2）之（AOP 面向切面编程）（AOP目录）

小灰灰 2022-04-16 02:19 203阅读 0赞

### **Spring Core：** ###

Spring的核心功能即IOC容器，解决对象的创建及对象之间的依赖关系

### **Spring WEB：** ###

Spring对WEB模块的支持

### **Spring AOP：** 面向切面编程 ###

1.  **AOP的概述**
2.  **AOP的底层实现**
3.  **Spring AOP开发**  
    **（网址： [https://blog.csdn.net/qq\_41029923/article/details/84230164][https_blog.csdn.net_qq_41029923_article_details_84230164] ）**
4.  **使用 AspectJ实现 AOP**  
    **（网址： [https://blog.csdn.net/qq\_41029923/article/details/84250237][https_blog.csdn.net_qq_41029923_article_details_84250237] ）**
5.  **Spring JDBC Template的使用**  
    **（网址： [https://blog.csdn.net/qq\_41029923/article/details/84291336][https_blog.csdn.net_qq_41029923_article_details_84291336] ）**

**1. AOP编程基本概念：**  
**AOP：** Aspect Object Programming 面向切面编程  
      功能：让关注点代码与业务代码分离  
**关注点：** 重复的代码（方法）  
**切面：** 关注点形成的类  
面向切面编程就是指对很多功能重复的代码的抽象，再在运行时向业务方法中动态的植入“切面类代码”；  
**切入点：** 通过切入点表达式，指定拦截哪些类的哪些方法，给指定的类在运行时植入切面类代码

**2. 代理模式：**  
代理模式是一种设计模式，提供了对目标对象的另外的访问方式即通过代理对象访问目标对象；  
**好处：** 可以在目标对象实现的基础上（即不改变目标对象的代码），增加额外的功能——扩展目标对象的功能

1.  **静态代理**  
    eg：保存数据到数据库，Dao直接保存； 添加事务；代理对象要实现与目标对象一样的接口；  
    **优点：** **可以做到在不修改目标对象功能的前提下（即目标对象代码不做更改），对目标对象进行扩展；**  
    **缺点：** **代理对象要实现与目标对象一样的接口，会有很多代理类，一旦接口增加方法，目标对象和代理对象都需要维护**（即因为两者都实现了此接口，所以代码都要做更改）  
    **解决方式：** 使用代理工厂、动态代理；
2.  **动态代理（也叫JDK代理、接口代理）**  
    **目标对象一定要实现接口，** 否则不能使用动态代理；  
    **代理对象不需要实现接口；**  
    代理对象的生成使用到 JDK API，动态的在内存中创建对象 （即 class $Proxy0 implements XXX）；  
    API中：  
    Proxy  
    public static Object newProxyInstance(  
          ClassLoader loader, //指定当前目标对象的使用类的加载器  
          Class<?> \[\] interfaces,//目标对象实现的接口类型  
          InvocationHandler h //事件处理器  
    )
3.  **Cglib代理（子类代理）**  
    子类代理，在内存中构建一个子类对象从而实现对目标对象的扩展，Cglib代理许多AOP框架使用；  
    步骤：  
          应用 .jar文件—Spring Core包中包含；  
          在内存中动态创建目标对象的子类；  
          目标对象不能是 final；  
          目标对象方法时 final、static，则不会拦截；

**在 Spring AOP 编程中：**  
动态代理：目标对象要实现接口，代理对象不需要实现接口（直接在代理对象中添加代码）；  
Cglib代理：目标对象不需要实现接口（代理对象实现了 MethodInterceptor 接口），（直接在代理对象中添加代码）；  
**如果加入容器中的目标对象实现了接口，会自动使用JDK代理；  
如果目标对象 没有 实现接口（且目标对象不是 final），会自动使用 Cglib代理；**

**eg：1. 静态代理**  
（**①** 接口IUserDao.java中有一个方法； **②** UserDao.java是目标对象：实现IUserDao接口，实现里面的方法；想添加事务，若直接在目标对象中添加， 这样不好，所以要新增一个代理对象UserDaoProxy； **③** UserDaoProxy.java是代理对象，要实现与目标对象 UserDao一样的接口 IUserDao。代理对象中添加目标对象，添加接口，因为目标对象实现了接口，这样可以通过添加接口来添加实现类，来调用目标对象中的方法，在调用方法前后添加事务即可；）

**1.1 IUserDao.java（接口）**

public interface IUserDao{
    	public void save() throws Exception;
    }

**1.2 UserDao.java（目标对象）**  
（UserDao.java中实现IUserDao接口，实现里面的方法；想添加事务，若直接在目标对象中添加， 这样不好）

**1.3 UserDaoProxy.java（代理对象\_静态代理）**  
（代理对象（UserDaoProxy）要实现与目标对象（UserDao）一样的接口（IUserDao）。代理对象中添加目标对象，添加接口，因为目标对象实现了接口，这样可以调用目标对象中的方法，在调用方法前后添加事务即可；）

public class UserDaoProxy implements IUserDao{
    	private IUserDao target;
    	public UserDaoProxy(IUserDao target){
    		this.target=target;
    	}
    	public void save() throws Exception{
    		System.out.println("----开始事务----");
    		target.save();
    		System.out.println("----提交事务----");
    	}
    }

**1.4 Test.java**  
（通过接口 IUserDao 生成一个目标对象 target，生成一个代理对象 proxy将 target传入，代理对象调用方法）

public class Test{
    	public static void main(String[] args) {
    		IUserDao target=new UserDao();//目标对象
    		UserDaoProxy proxy=new UserDaoProxy(target);//代理对象
    		try{
    			proxy.save();
    		}catch(Exception e){
    			e.printStackTrace();
    		}
    	}
    }

**运行结果：**  
![在这里插入图片描述][20181116104602933.png]  
**eg：2. 动态代理**  
（若接口中增加方法，目标对象实现了接口所以也要增加方法，但代理对象中不需要再增加方法；直接在测试类中调用增加的方法即可）  
**2.1 IUserDao.java（接口）**

public interface IUserDao{
    	public void save() throws Exception;
    	
    	public void update() throws Exception;
    }

**2.2 UserDao.java（目标对象）**  
（UserDao.java中实现IUserDao接口，实现里面的方法；想添加事务，若直接在目标对象中添加， 这样不好）

public class UserDao implements IUserDao{
    	public void save() throws Exception{
    		//System.out.println("----开始事务----");
    		System.out.println("----数据已保存----");
    		//System.out.println("----提交事务----");
    	}
    	
    	public void update() throws Exception{
    		System.out.println("----数据已修改----");
    	}
    }

**2.3 ProxyFactory.java**  
（代理工厂 ProxyFactory中有目标对象，private IUserDao target，因为目标对象所实现的接口不止有IUserDao，IUserDao换成Object会更好；目标对象要实现接口，代理对象不需要实现接口（直接在代理对象中添加代码））；

public class ProxyFactory{
    	private Object target;//目标对象
    	public ProxyFactory(Object target){
    		this.target=target;
    	}
    	public Object getProxyInstance(){//生成代理对象
    		Proxy.newProxyInstance(
    			target.getClass().getClassLoader(),
    			target.getClass().getInterfaces(),
    			new InvocationHandler(){
    				public Object invoke(Object proxy,Method method,Object[] args) throws Exception{
    					System.out.println("开始事务");
    					Object result=method.invoke(target,args);//调用目标对象方法
    					System.out.println("提交事务");
    					return result;
    				}
    			}
    		);
    	}
    }

**2.4 Test.java**

public class Test{
    	public static void main(String[] args) {
    		//目标对象
    		UserDao target=new UserDao();
    		//代理对象
    		IUserDao proxy=(IUserDao)new ProxyFactory(target).getProxyInstance();
    		//执行
    		try{
    			proxy.save();
    			
    			proxy.update();
    		}catch(Exception e){
    			e.printStackTrace();
    		}
    		System.out.println(proxy.getClass());
    	}
    }

**运行结果：**  
![在这里插入图片描述][20181116111411773.png]  
**接口中新增方法后运行结果：**  
![在这里插入图片描述][20181116135004909.png]  
**eg：3. Cglib 代理**  
**3.1 IUserDao.java（接口）**

public interface IUserDao{
    	public void save() throws Exception;
    	public void update() throws Exception;
    }

**3.2 UserDao.java（目标对象）**  
（UserDao.java不需要实现IUserDao接口）

public class UserDao{ //不能final(public final class UserDao)
    	public void save() throws Exception{ //不能是final、static(public final、static void save())
    		System.out.println("----数据已保存----");
    	}
    	public void update() throws Exception{
    		System.out.println("----数据已修改----");
    	}
    }

**3.3 ProxyFactory.java**  
（代理工厂 ProxyFactory中有目标对象，private IUserDao target，因为目标对象所实现的接口不止有IUserDao，IUserDao换成Object会更好；）

/*Cglib子类代理工厂(对UserDao在内存中创建一个代理)*/
    public class ProxyFactory implements MethodInterceptor{
    	private Object target;//目标对象
    	public ProxyFactory(Object target){
    		this.target=target;
    	}
    
    	//代理对象
    	public Object getProxyInstance(){
    		//1.工具类
    		Enhancer en=new Enhancer();
    		//2.设置父类
    		en.setSuperclass(target.getClass());
    		//3.设置回调方法(调用下方的intercept方法)
    		en.setCallback(this);
    		//4.创建代理对象
    		return en.create();
    	}
    	public Object intercept(Object arg0,Method arg1,Object[] arg2,MethodProxy arg3) throws Throwable{
    		System.out.println("开启事务------");
    		//执行目标对象的方法
    		Object resultValue=method.invoke(target,arg2);
    		System.out.println("结束事务");
    		return resultValue;
    	}
    }

**3.4 Test.java**

public class Test{
    	public static void main(String[] args) {
    		//目标对象
    		UserDao target=new UserDao();
    		//代理对象
    		IUserDao proxy=(IUserDao)new ProxyFactory(target).getProxyInstance();
    		//执行
    		try{
    			proxy.save();
    		}catch(Exception e){
    			e.printStackTrace();
    		}
    		System.out.println(proxy.getClass());
    	}
    }

**运行结果：**  
![在这里插入图片描述][20181116142252149.png]  
**目标对象 UserDao 是final的运行结果：**  
（目标对象不能是 final）  
会报错  
**目标对象中的方法 save 是final、static的运行结果：**  
（目标对象的方法如果是 final、static，则不会拦截（没有“开始事务、结束事务”））  
![在这里插入图片描述][20181116143231779.png]

[https_blog.csdn.net_qq_41029923_article_details_84230164]: https://blog.csdn.net/qq_41029923/article/details/84230164
[https_blog.csdn.net_qq_41029923_article_details_84250237]: https://blog.csdn.net/qq_41029923/article/details/84250237
[https_blog.csdn.net_qq_41029923_article_details_84291336]: https://blog.csdn.net/qq_41029923/article/details/84291336
[20181116104602933.png]: /images/20220416/65a18e9e36ea48019064767f4eb015fb.png
[20181116111411773.png]: /images/20220416/d99871b1776547c181486667f1ec600e.png
[20181116135004909.png]: /images/20220416/de9dabf419c94feabdc6a11ac5f21d6e.png
[20181116142252149.png]: /images/20220416/f04b7ef98237463cbda576792c70fe2c.png
[20181116143231779.png]: /images/20220416/a26b4d07a4484a2eb368f23c04a132b2.png