java代理模式,java代理模式有几种

本文目录一览：

• 1、java动态代理是什么
• 2、什么是java代理模式，具体相关的动态代理和静态代理分别是什么？举例更好啦~
• 3、Java 代理模式和装饰者模式的区别
• 4、java的代理模式有何用，直接调用用实现类不就行了吗，干嘛多此一举呢。。。。
• 5、java策略模式和代理模式有什么区别？

java动态代理是什么

import java.lang.reflect.Proxy;

A． 创建一个实现接口InvocationHandler的类，他必须实现invoke方法

B． 创建被代理的类以及接口。

C． 通过Proxy的静态方法newProxyInstance（ClassLoader loader，Class【】interfaces，InvocationHandler handler）创建一个代理

D． 通过代理调用方法。

java动态代理：是在运行是生成的class对象，在生成时必须提供一组或一个interface给它，然后该class就宣称它实现了这些interface。你当然可以把该class的实例当做这些interface中的任何一个来用，当然，这个DynamicProxy其实就是一个Proxy，他不会替你做实质性的工作，在生成它的实例时你必须提供一个handler，由它接管实际的工作。因此，DynamicProxy必须实现InvocationHandler接口。

5） 一个动态代理了和一个InvocationHandler 实现关联的。每一个动态代理实例的调用都要通过InvocationHandler接口的handler（调用处理器）来调用，动态代理不做任何执行操作，只是在创建动态代理时，把要实现的接口和handler关联，动态代理要帮助被代理执行的任务，要转交给handler来执行。其实就是调用invoke方法。

什么是java代理模式，具体相关的动态代理和静态代理分别是什么？举例更好啦~

简单的例子: HelloSpeaker.java

import java.util.logging.*;

public class HelloSpeaker {

private Logger logger = Logger.getLogger(this.getClass().getName());

public void hello(String name) {

logger.log(Level.INFO, “hello method starts….”); //日志记录

System.out.println(“Hello, ” + name); //!!!!!!!!!!!

logger.log(Level.INFO, “hello method ends….”); //日志记录

}

}

HelloSpeaker在执行hello()方法时，我们希望能记录该方法已经执行以及结束，

最简单的作法就是如上在执行的前后加上记录动作，然而Logger介入了HelloSpeaker中，

记录这个动作并不属于HelloSpeaker，这使得HelloSpeaker的职责加重。

——————————————————————————————

怎么办，用下面的方法或许好一些:

先定义一个接口:

public interface IHello {

public void hello(String name);

}

——————————————————————————————

实现该接口

public class HelloSpeaker implements IHello {

public void hello(String name) {

System.out.println(“Hello, ” + name);

}

}

public class Greeting implements IHello{

public void hello(String name){

System.out.println(“Greeting, ” + name);

}

}

——————————————————————————————

实现一个代理对象: HelloProxy

import java.util.logging.*;

public class HelloProxy implements IHello {

private Logger logger = Logger.getLogger(this.getClass().getName());

private IHello helloObject; //被代理对象

public HelloProxy(){}

public HelloProxy(IHello helloObject) {

this.helloObject = helloObject; //把被代理对象传入

}

public void setHelloObject(IHello helloObject){

this.helloObject = helloObject;

}

public IHello getHelloObject(){

return this.helloObject;

}

public void hello(String name) {

logger.log(Level.INFO, “hello method starts….”); //日志记录

helloObject.hello(name); //!!!!!!!!调用被代理对象的方法

logger.log(Level.INFO, “hello method ends….”); //日志记录

}

}

—————————————————————————————————–

执行:

IHello helloProxy = new HelloProxy(new HelloSpeaker()); //生成代理对象, 并给它传入一个被代理的对象

helloProxy.hello(“world”);

//IHello h=factory.getBean(“hello”); // IoC

//h.hello(“world”);

IHello helloProxy = new HelloProxy(new Greeting()); //生成代理对象, 并给它传入一个被代理的对象

helloProxy.hello(“world”);

—————————————————————————————————–

代理对象HelloProxy将代理真正的HelloSpeaker来执行hello()，并在其前后加上记录的动作，

这使得我们的HelloSpeaker在写时不必介入记录动作，HelloSpeaker可以专心于它的职责。

这是静态代理的基本范例，然而，代理对象的一个接口只服务于一种类的对象，而且如果要代理的方法很多，

我们势必要为每个方法进行代理，静态代理在程序规模稍大时就必定无法胜任.

Java在JDK 1.3之后加入协助开发动态代理功能的类，我们不必为特定对象与方法写特定的代理，使用动态代理，

可以使得一个handler服务于各个对象，首先，一个handler必须实现java.lang.reflect.InvocationHandler：

import java.util.logging.*;

import java.lang.reflect.*;

public class LogHandler implements InvocationHandler { //

private Logger logger = Logger.getLogger(this.getClass().getName());

private Object delegate; //被代理的对象

public Object bind(Object delegate) { //自定义的一个方法，用来绑定被代理对象的，返回值为被代理方法的返回值

this.delegate = delegate;

return Proxy.newProxyInstance(

delegate.getClass().getClassLoader(),

delegate.getClass().getInterfaces(),

this); //通过被代理的对象生成它的代理对象, 并同handler绑定在一起

}

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

Object result = null;

try {

logger.log(Level.INFO, “method starts…” + method); //日志记录

result = method.invoke(delegate, args); //!!!!!!!!调用被代理对象的方法

logger.log(Level.INFO, “method ends…” + method); //日志记录

} catch (Exception e){

logger.log(Level.INFO, e.toString());

}

return result;

}

}

InvocationHandler的invoke()方法会传入被代理对象的方法名称与参数, 实际上要执行的方法交由method.invoke()，

并在其前后加上记录动作，method.invoke()返回的对象是实际方法执行过后的回传结果。

动态代理必须有接口:

public interface IHello {

public void hello(String name);

}

实现该接口:

public class HelloSpeaker implements IHello {

public void hello(String name) {

System.out.println(“Hello, ” + name);

}

}

执行:

LogHandler logHandler = new LogHandler();

IHello helloProxy = (IHello) logHandler.bind(new HelloSpeaker()); //传入被代理对象, 传回代理对象

helloProxy.hello(“Justin”);

Java 代理模式和装饰者模式的区别

您好！

代理模式与装饰者模式看起来很像，都实现基础对象实现的接口，在其自身对象中都保存着对被代理/被装饰者的对象引用。

先来看看装饰者模式的定义：动态的将责任附加到被装饰者对象上，用于扩展对象的功能。比继承的灵活性大。典型的如Java IO的设计即是装饰者模式的典型应用。

代理模式模式的定义：对其他对象进行代理，以控制对被代理对象的访问。Spring的为业务逻辑层方法生成的代理类，主要进行一些事务控制等。

由定义可以看出装饰的责任是扩展功能 ，而代理主要控制访问。

具体例子可参看Java IO装饰/Spring的动态代理/Hibernate的代理等。

望采纳

java的代理模式有何用，直接调用用实现类不就行了吗，干嘛多此一举呢。。。。

使用代理类可以在实现类的基础上进行扩展，可以在方法中动态加入代码。这里要理解的是，实现类和代理类都是继承了同一个接口的(必须的)举个例子，如果你要通过一个实现类，将文本控件中输入的数字，做 加减乘除(也许还有很多运算) 法的运算，你发现这样会有一些问题存在，字符串如果不能转换成数字，就会报错。那么，你必须在方法的开头加入验证判断。但是，你又发现每个方法都要写验证是很麻烦的，而且代码量也会很多。于是你将验证抽取出来，成为一个方法。 每个运算方法都在开头调用这个验证就行了。这样是没有问题的。然而，如果这个实现类不是你写的，是A程序员写的，而A程序员觉得他无法知道，使用这个实现类的程序员是否希望验证这个字符串，所以，他把字符串的验证工作交给了调用的程序员。而你在使用这个实现类的时候，你不能修改这个实现类，给他的每个方法开头加入字符串的验证。那么怎么去让这个实现类的每个运算方法都在调用前都去验证一下呢？代理就可以动态的在每个方法前加入验证，比如add(int，int)方法，如果调用代理类的方法，代理类将先做验证，然后再去调用实现类的方法。这个是有必要的，因为代理的动态的加入验证代码，不需要每个方法钱都加入验证。最后总结一下，代理的作用大多是实现类的实现，对于调用者特定功能来说，做的还不够，这代理，可以加入那些还不够的代码，然后再去调用实现类。

java策略模式和代理模式有什么区别？

这2者 根本就不能 谈什么区别。。。

完全不是一回事

策略模式：

多个类只区别在表现行为不同，可以使用Strategy模式，在运行时动态选择具体要执行的行为。

代理模式

对其他对象提供一种代理以控制对这个对象的访问。