静态代理与动态代理

静态代理：
　　比如要在输出“HelloWorld”前打印一个字符串“Welcome”
　　A:先定义一个接口类
　　java 代码
　　package ttitfly.proxy;
　　public interface HelloWorld {
　　public void print(); // public void say();
　　}
　　
　　B: 定义一个该接口的实现类
　　java 代码
　　package ttitfly.proxy;
　　public class HelloWorldImpl implements HelloWorld{
　　
　　public void print(){
　　System.out.println("HelloWorld");
　　} // public void say(){ // System.out.println("SayHello!"); // }
　　}
　　
　　C:定义一个静态代理类
　　java 代码
　　package ttitfly.proxy;
　　public class StaticProxy implements HelloWorld{
　　
　　public HelloWorld helloWorld ;
　　public StaticProxy(HelloWorld helloWorld){
　　this.helloWorld = helloWorld;
　　}
　　
　　public void print(){
　　System.out.println("Welcome");
　　//相当于回调
　　helloWorld.print();
　　}
　　// public void say(){ // //相当于回调 //helloWorld.say(); // }
　　}
　　
　　D: 一个测试类:
　　java 代码
　　package ttitfly.proxy;
　　public class TestStaticProxy {
　　
　　public static void main(String[] args){
　　HelloWorld helloWorld = new HelloWorldImpl();
　　StaticProxy staticProxy = new StaticProxy(helloWorld);
　　staticProxy.print();
　　// staticProxy.say();
　　}
　　}

 

 

 

Java动态代理一——动态类Proxy的使用

1.什么是动态代理?

答：动态代理可以提供对另一个对象的访问，同时隐藏实际对象的具体事实。代理一般会实现它所表示的实际对象的接口。代理可以访问实际对象，但是延迟实现实际对象的部分功能，实际对象实现系统的实际功能，代理对象对客户隐藏了实际对象。客户不 知道它是与代理打交道还是与实际对象打交道。
2.为什么使用动态代理?

答：因为动态代理可以对请求进行任何处理

3.使用它有哪些好处?

答：因为动态代理可以对请求进行任何处理
4.哪些地方需要动态代理?

答：不允许直接访问某些类；对访问要做特殊处理等

 

目前Java开发包中包含了对动态代理的支持，但是其实现只支持对接口的的实现。其实现主要通过java.lang.reflect.Proxy类和java.lang.reflect.InvocationHandler接口。 

Proxy类主要用来获取动态代理对象，InvocationHandler接口用来约束调用者实现

以下为模拟案例，通过动态代理实现在方法调用前后向控制台输出两句字符串

目录结构

<br/>

定义一个HelloWorld接口

 1 package com.ljq.test;
 2
 3 /**
 4 * 定义一个HelloWorld接口
 5  *
 6 * @author jiqinlin
 7 *
 8 */
 9 publicinterface HelloWorld {
10     publicvoid sayHelloWorld();
11 }

<br/>

类PersonImpl是Person接口的实现

Person

package test;

 

publicinterface Person {

    publicvoid save();

    publicvoid speak();

    publicvoid eat(String name);

}

 

 

PersonImpl

package test;

 

publicclass PersonImpl implements Person{

    public String user = null;

    public PersonImpl(){}

    public PersonImpl(String user){

       this.user = user;

    }

   

    @Override

    publicvoid eat(String name) {

       // TODO Auto-generatedmethod stub

       System.out.println("eat...");

    }

 

    @Override

    publicvoid save() {

       System.out.println("save...");

    }

 

    @Override

    publicvoid speak() {

       System.out.println("speak...");

    }

   

}

 

PersonProxy是 InvocationHandler接口实现

package test;

 

import java.lang.reflect.InvocationHandler;

import java.lang.reflect.Method;

import java.lang.reflect.Proxy;

 

public class PersonProxy implements InvocationHandler{

    private Object object;

 

    public Object getObject() {

       return object;

    }

 

    public void setObject(Objectobject) {

       this.object = object;

    }

   

    public ObjectcreateProxyInstance(Object object){

       this.object = object;

       returnProxy.newProxyInstance(object.getClass().getClassLoader(), object.getClass().getInterfaces(),this);

    }

    @Override

    public Object invoke(Objectproxy, Method method, Object[] args)

           throws Throwable {

       Object result = null;

       PersonImpl p = (PersonImpl)this.object;

       if(p.user!=null){

           System.out.println("就是逗你玩...");

           result =method.invoke(this.object, args);

           System.out.println("想想还是算了...");

       }else{

           System.out.println("no...");

       }

       return result;

    }

   

   

}测试类

package test;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;


publicclass Test {

    publicstaticvoid main(String[] args) {
        PersonProxypro = new PersonProxy();

        Person p = (Person)pro.createProxyInstance(new PersonImpl("fsd"));

        p.eat("hi...");

        p.save();

         p.speak();
    }
}