静态代理

一、静态代理概念

代理模式:

目标对象类型的变量指向代理对象,然后调用方法的时候会执行代理对象的方法,
代理对象的方法里面重写或者调用了目标对象的方法,并且在方法执行前后添加了一些功能。

静态代理:

写好对应的代理类源文件,在编译期就已经确定了目标类和代理类。

分为两种:

(1)、继承方式:

代理类继承目标类,然后再代理类里面重写目标类的方法,在重写的方法里面,
通过super.的方式调用目标类的方法(父类方法),在调用前后做一些其它的处理。

public class CarProxy extends Car{
	
	public void run()
	{
		//给汽车加速的逻辑
		System.out.println("车加速！");
		super.run();
	}
	
	public void stop()
	{
		//给汽车减速的逻辑
		System.out.println("车减速！");
		super.stop();
	}
}


public class TestCar {
	@Test
	public void testDrive()
	{
		//通过继承方式
		Car car=new CarProxy();
		car.run();
		car.stop();
	}
}

(2)、聚合方式

代理类和目标类实现同一个接口,然后在代理类里面注入目标类,在代理类重写的方法里面通过注入的目标类调用目标类的同名方法,在这个方法执行前后添加一些逻辑处理。

public class CarProxy2 implements CarInterface{
 
	private Car car;
	public CarProxy2(Car car) {
		this.car=car;
	}
	
	@Override
	public void run() {
		//给汽车加速的逻辑
		System.out.println("车加速！");
		car.run();
	}

	@Override
	public void stop() {
		//给汽车减速的逻辑
		System.out.println("车减速！");
		car.stop();
	}
}


public class TestCar {
 
	@Test
	public void testDrive()
	{
		//通过聚合方式
		Car car=new Car();
		CarInterface proxy=new CarProxy2(car);
		proxy.run();
		proxy.stop();
	}
}

(3)、继承方式与聚合方式对比：

<1>、聚合方式实现,目标类和代理类必须实现同一个接口,
     如果目标类没有实现任何接口,则不能用聚合的方式。
 	 继承方式实现,目标类不需要实现接口。


 <2>、继承方式,目标类方法和自定义逻辑的顺序不能自由组合

	因为目标类方法和自定义逻辑的执行顺序不同,
	就要另外加一个代理类,不能自由组合。
		
	因为父子类继承是有固定的层级关系的,
	目标类方法和自定义逻辑的顺序是在代理类里面写死的。


按喇叭——>加速——>行驶
 
public class LabaProxy1 extends CarProxy{
	
	public void run()
	{
		//按喇叭的逻辑
		System.out.println("按喇叭！");
		super.run();
	}
	
	public void stop()
	{
		super.stop();
	}
	
}

 
public class TestCar {
 
	@Test
	public void testDrive()
	{
	        Car car=new LabaProxy1();
		car.run();
	}
}



加速——>行驶——>按喇叭


 
public class LabaProxy2 extends CarProxy{
	
	public void run()
	{
		//按喇叭的逻辑
		super.run();
		System.out.println("按喇叭！");
	}
	
	public void stop()
	{
		super.stop();
	}
	
}

 
public class TestCar {
 
	@Test
	public void testDrive()
	{
	        Car car=new LabaProxy2();
		car.run();
	}
}

<3>、聚合方式,目标类方法和自定义逻辑的顺序可以自由组合

因为聚合方式是通过属性注入的方式来实现调用目标方法的,
所以可以自由组合,传入不同的目标类即可。

注入不同的属性,调用不同的目标方法,
这种方式可以更灵活的组合代理类。



按喇叭——>加速——>行驶

 
public class LabaProxy3 implements CarInterface{
	
	private CarInterface car;
	
	public LabaProxy3(CarInterface car) {
		this.car=car;
	}
	
	@Override
	public void run() {
		//按喇叭的逻辑
		System.out.println("按喇叭！");
		car.run();
	}
 
	@Override
	public void stop() {
		car.stop();
	}
 
}


 
public class TestCar {
 
	@Test
	public void testDrive()
	{        
		//被代理类
		Car car=new Car(); //行驶
		//速度代理类
		CarProxy2 cp=new CarProxy2(car); //加速-》行驶
		//喇叭代理类
 		//按喇叭-》加速-》行驶
		CarInterface proxy=new LabaProxy3(cp); 
		proxy.run();
	}
	
}

加速——>按喇叭——>行驶

调换顺序即可


public class TestCar {
 
	@Test
	public void testDrive()
	{
		//被代理类
		Car car=new Car();  //行驶
		//喇叭代理类
		//按喇叭-》行驶
		CarInterface proxy=new LabaProxy3(car);  
		//速度代理类
		//加速-》按喇叭-》行驶
		CarProxy2 cp=new CarProxy2(proxy); 
		cp.run();
	}
	
}

继承方式：

每多一个逻辑，多一个代理类；
逻辑顺序改变一次顺序，多一个代理类

聚合方式：

每多一个逻辑，多一个代理类；

逻辑顺序改变一次顺序，只需在注入属性时灵活组合。