2.1 Java反射技术
Java反射技术内容包括： 对象构建，反射方法， 注解，参数，接口等。
本书主要讲解对象构建和方法的反射调用。
2.1.1 通过反射构建对象
通过反射的方法构建
package com.lean.ssm.chapter2.reflect;
public class ReflectServiceImpl {
public void sayHello(String name) {
System.err.println("Hello" + name);
}
//通过反射的方法构建
//通过newInstance方法初始化了一个类对象
//无参数的类的反射生成
public ReflectServiceImpl getInstance() {
ReflectServiceImpl object = null;
try {
object = (ReflectServiceImpl)
Class.forName("com.lean.ssm.chapter2.reflect.ReflectServiceImpl").
newInstance();
} catch (ClassNotFoundException | InstantiationException
| IllegalAccessException ex) {
ex.printStackTrace();
}
return object;
}
}
用反射构建含参数的类的反射生成
package com.lean.ssm.chapter2.reflect;
import java.lang.reflect.InvocationTargetException;
public class ReflectServiceImpl2 {
private String name;
public ReflectServiceImpl2(String name) {
this.name = name;
}
public void sayHello() {
System.err.println("Hello" + name);
}
//用反射构建含参数的类的反射生成
//先通过forName加载到类的加载器。然后通过getContructor方法，参数可以有多个，
//这里定义为String.class。意为有且只有一个参数类型为String的构建方法
public ReflectServiceImpl2 getInstance() {
ReflectServiceImpl2 object = null;
try {
object =
(ReflectServiceImpl2)
Class.forName("com.lean.ssm.chapter2.reflect.ReflectServiceImpl2").
getConstructor(String.class).newInstance("张三");
} catch (ClassNotFoundException | InstantiationException |
IllegalAccessException | NoSuchMethodException |
SecurityException | IllegalArgumentException |
InvocationTargetException ex) {
ex.printStackTrace();
}
return object;
}
}
2.1.2反射方法
以ReflectServiceImpl类为例
//反射生成对象和反射调度方法
public Object reflect() {
ReflectServiceImpl object = null;
try {
object = (ReflectServiceImpl)
Class.forName("com.lean.ssm.chapter2.reflect.ReflectServiceImpl").newInstance();
Method method = object.getClass().getMethod("sayHello", String.class);
method.invoke(object, "张三");
} catch (NoSuchMethodException | SecurityException
| ClassNotFoundException | IllegalAccessException
| IllegalArgumentException | InvocationTargetException
| InstantiationException ex) {
ex.printStackTrace();
}
return object;
}
2.2 动态代理模式和责任链模式
动态代理的意义在于生成一个占位（又称代理对象），来代理真实对象，从而控制真实对象的访问
代理的作用是，在真实对象访问之前或者之后加入对应的逻辑，或者根据其他规则控制是否使用真实对象
代理分为两个步骤
代理对象和真实对象建立代理关系
实现代理对象的代理逻辑方法
2.2.1 JDK动态代理
JDK动态代理是java.lang.reflect.*包提供的方式，必须借助一个接口才能产生代理对象，所以先定义接口
上代码
package com.lean.ssm.chapter2.proxy.jdkproxy;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import org.junit.Test;
/**
* 在jdk动态代理中，要实现代理逻辑类必须去实现java.lang.reflect.InvocationHandler接口
* 它里面定义了一个invoke方法，并提供接口数组用于下挂代理对象
* @author Administrator
*
*/
public class JdkProxyExample implements InvocationHandler {
//真实对象
private Object target = null;
/*
* 建立代理对象和真实对象的代理关系，并返回代理对象
* @param target：真实对象
* @return 真实对象
*/
public Object bind(Object target) {
this.target = target;
return Proxy.newProxyInstance(target.getClass().getClassLoader(),
target.getClass().getInterfaces(), this);
}
/**
* 第1步，建立代理对象和真实对象的关系
* 代理方法逻辑
* @param proxy 代理对象
* @param method 当前调度方法
* @param args 当前方法参数
* @return 代理结果返回
* @throws Throwable 异常
*/
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("进入代理逻辑方法");
System.out.println("在调度真实对象之前的服务");
Object obj = method.invoke(target, args); //相当于调用sayHello方法
System.out.println("在调度真实对象之后的服务");
return obj;
}
/**
* 第2步，实现代理逻辑方法
*/
@Test
public void testJdkProxy() {
JdkProxyExample jdk = new JdkProxyExample();
//绑定关系，因为挂在接口HelloWorld下，所以声明代理对象HelloWorld proxy
HelloWorld proxy = (HelloWorld) jdk.bind(new HelloWorldImpl());
proxy.sayHelloWorld();
}
}
执行结果：
进入代理逻辑方法
在调度真实对象之前的服务
Hello World
在调度真实对象之后的服务
2.2.2 CGLIB动态代理
在一些不能提供接口的环境中，只能采用其他第三方技术，比如CGLIB动态代理
package com.lean.ssm.chapter2.proxy.cilibproxy;
import java.lang.reflect.Method;
import org.junit.Test;
import com.lean.ssm.chapter2.reflect.ReflectServiceImpl;
import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
public class CglibProxyExample implements MethodInterceptor {
/**
* 生成CGLIB代理对象
* @param cls —— Class类
* @return Class类的CGLIB代理对象
*/
public Object getProxy(Class cls) {
//CGLIB enhancer增强类对象
Enhancer enhancer = new Enhancer();
//设置增强类型
enhancer.setSuperclass(cls);
//定义代理逻辑对象为当前对象，要求当前对象实现MethodInterceptor方法
enhancer.setCallback(this);
//生成并返回代理对象
return enhancer.create();
}
/**
* 代理逻辑方法
* @param proxy 代理对象
* @param method 方法
* @param args 方法参数
* @return 代理逻辑返回
* @throws Throwable 异常
*/
@Override
public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
System.err.println("调用真实对象前");
//CGLIB 反射调用真实对象方法
Object result = methodProxy.invokeSuper(proxy, args);
System.err.println("调用真实对象后");
return result;
}
@Test
public void tesCGLIBProxy() {
CglibProxyExample cpe = new CglibProxyExample();
ReflectServiceImpl obj = (ReflectServiceImpl) cpe.getProxy(ReflectServiceImpl.class);
obj.sayHello("张三");
}
}
执行结果为：
调用真实对象前
Hello张三
调用真实对象后
2.2.3 拦截器 + 责任链模式
由于动态代理一般都比较难理解，程序设计者会设计一个拦截器接口供开发者使用，开发者只要知道拦截器接口的方法，含义和作用即可，无需知道动态代理是怎么实现的。
package com.lean.ssm.chapter2.intercept;
import java.lang.reflect.Method;
public interface Interceptor {
public boolean before(Object proxy, Object target, Method method, Object[] args);
public void around(Object proxy, Object target, Method method, Object[] args);
public void after(Object proxy, Object target, Method method, Object[] args);
}
package com.lean.ssm.chapter2.intercept;
import java.lang.reflect.Method;
public class Interceptor1 implements Interceptor {
public boolean before(Object proxy, Object target, Method method, Object[] args) {
System.out.println("【拦截器1】的before方法");
return true;
}
public void around(Object proxy, Object target, Method method, Object[] args) {
}
public void after(Object proxy, Object target, Method method, Object[] args) {
System.out.println("【拦截器1】的after方法");
}
}
package com.lean.ssm.chapter2.intercept;
import java.lang.reflect.Method;
public class Interceptor2 implements Interceptor {
public boolean before(Object proxy, Object target, Method method, Object[] args) {
System.out.println("【拦截器2】的before方法");
return true;
}
public void around(Object proxy, Object target, Method method, Object[] args) {}
public void after(Object proxy, Object target, Method method, Object[] args) {
System.out.println("【拦截器2】的after方法");
}
}
package com.lean.ssm.chapter2.intercept;
import java.lang.reflect.Method;
public class Interceptor3 implements Interceptor {
public boolean before(Object proxy, Object target, Method method, Object[] args) {
System.out.println("【拦截器3】的before方法");
return true;
}
public void around(Object proxy, Object target, Method method, Object[] args) {}
public void after(Object proxy, Object target, Method method, Object[] args) {
System.out.println("【拦截器3】的after方法");
}
}
package com.lean.ssm.chapter2.intercept;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
public class InterceptorJdkProxy implements InvocationHandler {
private Object target; //真实对象
private String interceptorClass = null;//拦截器全限定名
public InterceptorJdkProxy(Object target, String interceptorClass) {
this.target = target;
this.interceptorClass = interceptorClass;
}
/**
* 绑定委托对象并返回一个【代理占位】
*
* @param target 真实对象
* @return 代理对象【占位】
*/
public static Object bind(Object target, String interceptorClass) {
//取得代理对象
return Proxy.newProxyInstance(target.getClass().getClassLoader(),
target.getClass().getInterfaces(),
new InterceptorJdkProxy(target, interceptorClass));
}
@Override
/**
* 通过代理对象调用方法，首先进入这个方法.
*
* @param proxy --代理对象
* @param method --方法，被调用方法
* @param args -- 方法的参数
*/
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
if (interceptorClass == null) {
//没有设置拦截器则直接反射原有方法
return method.invoke(target, args);
}
Object result = null;
//通过反射生成拦截器
Interceptor interceptor =
(Interceptor) Class.forName(interceptorClass).newInstance();
//调用前置方法
if (interceptor.before(proxy, target, method, args)) {
//反射原有对象方法
result = method.invoke(target, args);
} else {//返回false执行around方法
interceptor.around(proxy, target, method, args);
}
//调用后置方法
interceptor.after(proxy, target, method, args);
return result;
}
}
package com.lean.ssm.chapter2.intercept;
import java.lang.reflect.Method;
public class MyInterceptor implements Interceptor {
@Override
public boolean before(Object proxy, Object target, Method method, Object[] args) {
System.err.println("反射方法前逻辑");
return false;// 不反射被代理对象原有方法
}
@Override
public void after(Object proxy, Object target, Method method, Object[] args) {
System.err.println("反射方法后逻辑。");
}
@Override
public void around(Object proxy, Object target, Method method, Object[] args) {
System.err.println("取代了被代理对象的方法");
}
}
package com.lean.ssm.chapter2.intercept;
import com.lean.ssm.chapter2.proxy.jdkproxy.HelloWorld;
import com.lean.ssm.chapter2.proxy.jdkproxy.HelloWorldImpl;
public class TestInterceptor {
public static void main(String[] args) {
testInterceptor();
testChain();
}
//测试拦截器
public static void testInterceptor() {
HelloWorld proxy = (HelloWorld) InterceptorJdkProxy.bind(new HelloWorldImpl(),
"com.lean.ssm.chapter2.intercept.MyInterceptor");
proxy.sayHelloWorld();
}
//测试责任链模式
public static void testChain() {
HelloWorld proxy1 = (HelloWorld) InterceptorJdkProxy.bind(
new HelloWorldImpl(), "com.lean.ssm.chapter2.intercept.Interceptor1");
HelloWorld proxy2 = (HelloWorld) InterceptorJdkProxy.bind(
proxy1, "com.lean.ssm.chapter2.intercept.Interceptor2");
HelloWorld proxy3 = (HelloWorld) InterceptorJdkProxy.bind(
proxy2, "com.lean.ssm.chapter2.intercept.Interceptor3");
proxy3.sayHelloWorld();
}
}
拦截器步骤：
- 在bind方法中用JDK动态代理绑定了一个对象，然后返回代理对象
- 如果没有设置拦截器，则直接反射真实对象的方法， 然后结束，否则进行第3步
- 通过反射生成拦截器，并准备使用它
- 调用拦截器的reflect方法， 如果返回味true，反射原来的方法，否则运行拦截器的around方法
- 调用拦截器的after方法
- 返回结果
2.3 观察者模式（Observer）
观察者模式定义了一种一对多的依赖关系，让多个观察者对象同时监视着被观察者的状态，当被观察者的状态发生变化时，会通知所有观察者，并让其自动更新自己。
观察者模式可以避免if语句带来的责任不清的情况。
package com.lean.ssm.chapter2.observer;
import java.util.ArrayList;
import java.util.List;
import java.util.Observable;
import java.util.Observer;
public class ProductList extends Observable {
private List<String> productList = null;//产品列表
private static ProductList instance;//类唯一实例
private ProductList() {}//构建方法私有化
/**
* 取得唯一实例
* @return 产品列表唯一实例
*/
public static ProductList getInstance() {
if (instance == null) {
instance = new ProductList();
instance.productList = new ArrayList<String>();
}
return instance;
}
/**
* 增加观察者（电商接口）
* @param observer 观察者
*/
public void addProductListObserver(Observer observer) {
this.addObserver(observer);
}
/**
* 新增产品
* @param newProduct 新产品
*/
public void addProudct(String newProduct) {
productList.add(newProduct);
System.err.println("产品列表新增了产品："+newProduct);
this.setChanged();//设置被观察对象发生变化
this.notifyObservers(newProduct);//通知观察者，并传递新产品
}
}
package com.lean.ssm.chapter2.observer;
import java.util.Observable;
import java.util.Observer;
public class JingDongObserver implements Observer {
@Override
public void update(Observable o, Object product) {
String newProduct = (String) product;
System.err.println("发送新产品【"+newProduct+"】同步到京东商城");
}
}
package com.lean.ssm.chapter2.observer;
import java.util.Observable;
import java.util.Observer;
public class TaoBaoObserver implements Observer {
@Override
public void update(Observable o, Object product) {
String newProduct = (String) product;
System.err.println("发送新产品【"+newProduct+"】同步到淘宝商城");
}
}
package com.lean.ssm.chapter2.observer;
public class ObserverTest {
public static void main(String[] args) {
ProductList observable = ProductList.getInstance();
TaoBaoObserver taoBaoObserver = new TaoBaoObserver();
JingDongObserver jdObserver = new JingDongObserver();
observable.addObserver(jdObserver);
observable.addObserver(taoBaoObserver);
observable.addProudct("新增产品1");
}
}
2.5 建造者模式（builder）
建造者模式属于对象的创建模式，可以将一个产品的内部表象（属性）与产品的生成过程分割开来，从二使一个建造过程生成具有不同内部表象的产品对象。
package com.lean.ssm.chapter2.builder;
public class TicketHelper {
public void buildAdult(String info) {
System.err.println("构建成年人票逻辑：" + info);
}
public void buildChildrenForSeat(String info) {
System.err.println("构建有座儿童票逻辑：" + info);
}
public void buildchildrenNoSeat(String info) {
System.err.println("构建无座儿童票逻辑：" + info);
}
public void buildElderly(String info) {
System.err.println("构建有老年人票逻辑：" + info);
}
public void buildSoldier(String info) {
System.err.println("构建军人及其家属票逻辑：" + info);
}
}
package com.lean.ssm.chapter2.builder;
public class TicketBuilder {
public static Object builder(TicketHelper helper) {
System.out.println("通过TicketHelper构建套票信息");
return null;
}
}
package com.lean.ssm.chapter2.builder;
public class BuilderTest {
public static void main(String[] args) {
TicketHelper helper = new TicketHelper();
helper.buildAdult("成人票");
helper.buildChildrenForSeat("有座儿童");
helper.buildchildrenNoSeat("无票儿童");
helper.buildElderly("老人票");
helper.buildSoldier("军人票");
Object ticket = TicketBuilder.builder(helper);
}
}
293
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
