7.2 没有代理的代码(静态代理)
追求者中间没有代理人,代理人可以代替追求者给女孩送花等。
现在没有代理人的代码
//追求者类
class Pursuit {
SchoolGirl mm;
public Pursuit(SchoolGirl mm){
this.mm = mm;
}
public void giveDolls(){
printf("送洋娃娃");
}
public void giveFlowers(){
printf("送花");
}
public void giveChocolate(){
printf("送巧克力");
}
}
//被追求者类
class SchoolGirl {
private String name;
public void setName(String name){
this.name = name;
}
public String getName(){
return name;
}
}
//客户端
public class Main{
public static void main(String[] args){
SchoolGirl girl = new SchoolGirl();
girl.setName("娇娇");
}
//现在追求者赵直接把礼物送给娇娇,但是娇娇并不认识追求者,
//这样写说明娇娇认识追求者赵,有逻辑错误
Pursuit zhao = new Pursuit(girl);
zhao.giveDolls();
zhao.giveFlowers();
zhao.giveChocolate();
}
事实上,追求者(Pursuit)通过代理人(Proxy)送给被追求者(SchoolGirl)
追求者和代理都有相同送礼物的三个方法。有相同的方法就可以有共同的接口。
7.4 符合实际代码
//代理接口
public interface GiveGift {
void giveDolls();
void giveFlowers();
void giveChocolate();
}
//追求者类
class Pursuit implements GiveGift {
SchoolGirl mm;
public Pursuit(SchoolGirl mm){
this.mm = mm;
}
public void giveDolls(){
printf("送洋娃娃");
}
public void giveFlowers(){
printf("送花");
}
public void giveChocolate(){
printf("送巧克力");
}
}
//代理类
class Proxy implements GiveGift {
Pursuit gg;
public Proxy(SchoolGirl mm){
gg = new Pursuit(mm);
}
//实现方法中调用“追求者”类的方法
public void giveDolls(){
gg.giveDolls();
}
public void giveFlowers(){
gg.giveFlowers();
}
public void giveChocolate(){
gg.giveChocolate();
}
}
//客户端
public class Main {
public static void main(String[] args){
SchoolGirl girl = new SchoolGirl();
girl.setName("娇娇");
Proxy p = new Proxy(girl);
p.giveDolls();
p.giveFlowers();
p.giveChocolate();
}
}
7.5 静态代理模式
为其他对象提供一种代理以控制这个对象的访问。
Subject类定义了RealSubject和Proxy的共用接口,在任何使用RealSubject,都可以用Proxy
public interface Subject {
public void request();
}
RealSubject类,定义Proxy所代表的真实实体。
public class RealSubject implements Subject {
@Override
public void request(){
println("真实请求");
}
}
Proxy类,保存一个引用使用代理可以访问实体,实现Subject接口,代理就可以用来代替实体。
public class Proxy implements Subject {
RealSubject real;
@Override
public void request(){
if(real == null){
real = new RealSubject();
}
real.request();
}
}
客户端
public class Main {
public static void main(String[] args){
Proxy proxy = new Proxy();
proxy.request();
}
}
缺点:
每一个代理类都必须实现一遍委托类(也就是realsubject)的接口,如果接口增加方法,则代理类也必须跟着修改。其次,代理类每一个接口对象对应一个委托对象,如果委托对象非常多,则静态代理类就非常臃肿,难以胜任。
7.6 动态代理
是根据代理的对象,动态创建代理类
可以避免静态代理中代理类的方法过多的问题
动态代理是实现方式,是通过反射来实现的,借助Java自带的++java.lang.reflect.Proxy++,通过固定规则生成。
步骤:
- 编写一个委托类的接口,即静态代理的(Subject接口)
- 实现一个真正的委托类,即静态代理的(RealSubject类)
- 创建一个动态代理类,实现 ++InvocationHandler++ 接口,并重写该 ++invoke++ 方法
- 在测试类中,生成动态代理的对象。
第3步的代码:
public class DynamicProxy implements InvocationHandler {
private Object object;
public DynamicProxy(Object object) {
this.object = object;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
Object result = method.invoke(object, args);
return result;
}
}
第4步代码:
public static void main(String[] args){
Subject realSubject = new RealSubject();
DynamicProxy proxy = new DynamicProxy(realSubject);
ClassLoader classLoader = realSubject.getClass().getClassLoader();
Subject subject = (Subject) Proxy.newProxyInstance(classLoader, new Class[]{Subject.class}, proxy);
subject.visit();
}
创建动态代理对象,需要 ++Proxy.newProxyInstance++
该方法三个参数:
- ClassLoader loader表示当前使用到的appClassloader。
- Class
/**
* 创建动态代理对象
* 动态代理不需要实现接口,但是需要指定接口类型
*/
public class ProxyFactory{
//维护一个目标对象
private Object target;
public ProxyFactory(Object target){
this.target=target;
}
//给目标对象生成代理对象
public Object getProxyInstance(){
return Proxy.newProxyInstance(
target.getClass().getClassLoader(),
target.getClass().getInterfaces(),
new InvocationHandler() {
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("开始事务2");
//执行目标对象方法
Object returnValue = method.invoke(target, args);
System.out.println("提交事务2");
return returnValue;
}
}
);
}
}
测试类
public class App {
public static void main(String[] args) {
// 目标对象
IUserDao target = new UserDao();
// 【原始的类型 class cn.itcast.b_dynamic.UserDao】
System.out.println(target.getClass());
// 给目标对象,创建代理对象
IUserDao proxy = (IUserDao) new ProxyFactory(target).getProxyInstance();
// class $Proxy0 内存中动态生成的代理对象
System.out.println(proxy.getClass());
// 执行方法 【代理对象】
proxy.save();
}
}
总结:
代理对象不需要实现接口,但是目标对象一定要实现接口,否则不能用动态代理
7.7 CGLib代理
上面的Java动态代理和静态代理都要求目标对象要实现一个接口,但有时候一个类没有实现接口,只要这个类自己,如果代理该类就要用CGLib代理。
介绍:也叫作子类代理,它是在内存中构建一个子类对象从而实现对目标对象功能的扩展.
Cglib子类代理实现方法:
- 需要引入cglib的jar文件,但是Spring的核心包中已经包括了Cglib功能,所以直接引入 ++pring-core-3.2.5.jar++ 即可
- 引入功能包后,就可以在内存中动态构建子类
- 代理的类不能为final,否则报错
- 目标对象的方法如果为final/static,那么就不会被拦截,即不会执行目标对象额外的业务方法.
目标对象类:UserDao.java
public class UserDao {
public void save() {
System.out.println("----已经保存数据!----");
}
}
Cglib代理工厂:ProxyFactory.java
/**
* 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.设置回调函数
en.setCallback(this);
//4.创建子类(代理对象)
return en.create();
}
@Override
public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
System.out.println("开始事务...");
//执行目标对象的方法
Object returnValue = method.invoke(target, args);
System.out.println("提交事务...");
return returnValue;
}
}
测试类
public class App {
@Test
public void test(){
//目标对象
UserDao target = new UserDao();
//代理对象
UserDao proxy = (UserDao)new ProxyFactory(target).getProxyInstance();
//执行代理对象的方法
proxy.save();
}
}
在Spring的AOP编程中:
如果加入容器的目标对象有实现接口,用JDK代理
如果目标对象没有实现接口,用Cglib代理