Spring入门3----Spring的重重重点AOP

Spring 的核心概念—AOP，这也是 Spring 框架中最为核心的一个概念。
它利用一种称为"横切"的技术，剖解开封装的对象内部，并将那些影响了多个类的公共行为封装到一个可重用模块，并将其命名为"Aspect"，即切面。所谓"切面"，简单说就是那些与业务无关，却为业务模块所共同调用的逻辑或责任封装起来，便于减少系统的重复代码，降低模块之间的耦合度，并有利于未来的可操作性和可维护性。
什么是切面，什么是公共模块，那么我们概念少说，直接通过一个实例来看看 AOP 到底是什么。
需求:
现在有一张表 User,然后我们要在程序中实现对 User 表的增加和删除操作。
要求：增加和删除操作都必须要开启事务，操作完成之后要提交事务。
User.java

package com.dn.aop.one;

public class User {
	private int uid;
	private String uname;
	
	public int getUid() {
		return uid;
	}
	public void setUid(int uid) {
		this.uid = uid;
	}
	public String getUname() {
		return uname;
	}
	public void setUname(String uname) {
		this.uname = uname;
	}
}

解决办法1：使用静态代理
第一步：创建 UserService 接口

package com.dn.aop.one;

public interface UserService {
	//添加user
	public void addUser(User user);
	//删除user
	public void deleteUser(int uid);
}

第二步:创建 UserService的实现类

package com.dn.aop.one;

public class UserServiceImpl implements UserService {

	@Override
	public void addUser(User user) {
		System.out.println("增加User");
	}
	@Override
	public void deleteUser(int uid) {
		System.out.println("删除User");
	}
}

第三步：创建事务类 MyTransaction

package com.dn.aop.one;
//创建事务类
public class MyTransaction {
	//开启事务
	public void before(){
		System.out.println("开启事务");
	}
	//提交事务
	public void after(){
		System.out.println("提交事务");
	}
}

第四步：创建代理类ProxyUser.java并测试

package com.dn.aop.one;

import org.testng.annotations.Test;

public class ProxyUser implements UserService {
	//真实类
	private UserService userService;
	//事务类
	private MyTransaction transaction;
	//使用构造函数实例化
	public ProxyUser(UserService userService, MyTransaction transaction){
		this.userService = userService;
		this.transaction = transaction;
	}
	@Override
	public void addUser(User user) {
		transaction.before();
		userService.addUser(user);
		transaction.after();

	}

	@Override
	public void deleteUser(int uid) {
		transaction.before();
		userService.deleteUser(uid);
		transaction.after();
	}
	
	public static void testOne(){
		MyTransaction transaction = new MyTransaction();
		UserService userService = new UserServiceImpl();
		//产生静态代理对象
		ProxyUser proxy = new ProxyUser(userService, transaction);
		proxy.addUser(null);
		proxy.deleteUser(0);
	}
	public static void main(String[] args) {
		ProxyUser.testOne();
	}

}

这是一个很基础的静态代理，业务类UserServiceImpl 只需要关注业务逻辑本身，保证了业务的重用性，这也是代理类的优点，没什么好说的。我们主要说说这样写的缺点：

①、代理对象的一个接口只服务于一种类型的对象，如果要代理的方法很多，势必要为每一种方法都进行代理，静态代理在程序规模稍大时就无法胜任了。

②、如果接口增加一个方法，比如 UserService 增加修改 updateUser(）方法，则除了所有实现类需要实现这个方法外，所有代理类也需要实现此方法。增加了代码维护的复杂度。