静态代理

静态代理

什么是静态代理

什么是代理？代理就是给目标类提供一个代理对象，由代理对象控制目标对象的引用
代理有啥好处呢？①通过代理对象的方式间接的访问目标对象，防止直接访问目标对象给系统带来的不必要复杂性，②通过代理对象对原有的业务增强

实现静态代理的步骤

• 抽象出真实角色和代理角色的共同动作
• 构建真实角色
• 构建代理角色，代理角色中有对真实角色的引用

两个案例

案例一

房东通过中介租房给租客

房东：真实角色，并实现对共同行为

中介：代理角色，并实现共同的行为

共同的动作：租房

代码实现

1. 抽象出共同的行为

//抽象出共同的动作
public interface Rent {
	void zufang();

}

2. 构建真角色并实现租房这个共有的行为

//真实角色
public class Fangdong implements Rent{

	@Override
	public void zufang() {
		
		System.out.println("房东要租房");
	}

}

3. 构建代理角色并实现Rent接口

//构建代理角色并实现Rent接口
public class Zhongjie implements Rent{
	private Fangdong fangdong;
	Zhongjie(Fangdong fangdong){
		this.fangdong=fangdong;
	}//对真实角色的引用
	@Override
	public void zufang() {
		kanFang();//增强方法
		fangdong.zufang();//本来的方法
		shoufei();//增强的方法
	}

	private void kanFang(){
		System.out.println("中介看房");
	}
	private void shoufei(){
		System.out.println("完事收钱");
	}
}

4. 测试

public class Test {
	public static void main(String[] args) {
//		MerryCompary merryCompary =new MerryCompary(new Guen());
//		merryCompary.happyMerry();
		Zhongjie zhongjie =new Zhongjie(new Fangdong());//代理对象
		zhongjie.zufang();
		
	}


}

5. 结果

中介看房
房东要租房
完事收钱

案例二

在不改变原来的代码基础还是那个增强功能

现在有一个userService 接口有增删改查4个方法，现在要添加利用日志功能

• 接口，相当于共同的行为

//共有的方法
public interface UserService {
	
	public void add();
	public void delete();
	public void updete();
	public void select();
	
	

}

• 接口实现类，相当于真实角色

//真实角色
public class UserServiceImpl implements UserService{

	@Override
	public void add() {
		System.out.println("添加里一个用户");
		
	}

	@Override
	public void delete() {
		System.out.println("删除了一个用户");
		
	}

	@Override
	public void updete() {
		System.out.println("更新了一个用户");
		
	}

	@Override
	public void select() {
		System.out.println("删除了一个用户");
		
	}

}

• 添加代理角色，实现抽象接口

//代理角色
public class UserServiceProxy implements UserService{
	private UserServiceImpl userServiceImpl;
	public void setUserService(UserServiceImpl userServiceImpl){
		this.userServiceImpl= userServiceImpl;
	}//代理角色对真实角色的引用
	
	@Override
	public void add() {
		log("add");//增强的方法
		userServiceImpl.add();//真实角色的方法
		
	}

	@Override
	public void delete() {
		log("delete");
		userServiceImpl.delete();
		
	}

	@Override
	public void updete() {
		log("updete");
		userServiceImpl.updete();
		
		
	}

	@Override
	public void select() {
		log("select");
		userServiceImpl.select();
		
	}
	//增强方法
	public void log(String msg){
		
		System.out.println("使用了"+msg+"方式");
	}

}

• 编写测试类

public class Test1 {

	public static void main(String[] args) {
		UserServiceProxy userServiceProxy = new UserServiceProxy();//构建代理对象
		userServiceProxy.setUserService(new UserServiceImpl());
		userServiceProxy.add();
		userServiceProxy.delete();
		
	}
}

• 执行结果，不但有原来的功能，增加了一个日志功能

使用了add方式
添加里一个用户
使用了delete方式
删除了一个用户

静态代理的优缺点

优点：

1. 业务类只需要关注业务逻辑本身，保证了业务类的重用性。这是代理模式的共有优点。
2. 对于我们不关心的方法，全部委托给被代理的对象处理。

缺点：

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

2. 如果接口增加一个方法，除了所有实现类需要实现这个方法外，所有代理类也需要实现此方法。显而易见，增加了代码维护的复杂度。

3. 不能处理未知类型的数据，静态的类都是在运行前就编译确定好的