一、Java反射技术
1、通过反射建立对象
新建一个对象
//ReflectServiceImp1.java
package com.lean.ssm.chapter2.reflect;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
public class ReflectServiceImp1 {
public void sayHello(String name){
System.out.println("Hello " + name);
}
}
然后通过反射的方法构建(无参数构造方法):
public ReflectServiceImp1 getInstance(){
ReflectServiceImp1 object = null;
try{
object = (ReflectServiceImp1)
Class.forName("com.lean.ssm.chapter2.reflect.ReflectServiceImp1").newInstance();
}catch(ClassNotFoundException | InstantiationException | IllegalAccessException e){
e.printStackTrace();
}
return object;
}
若是想要构造带有参数的,如下:
package com.lean.ssm.chapter2.reflect;
import java.lang.reflect.InvocationTargetException;
public class ReflectServiceImp2 {
private String name;
public ReflectServiceImp2(String name){
this.name = name;
}
public void sayHello(){
System.out.println("Hello " + name);
}
通过反射构造对象:
public ReflectServiceImp2 getInstance(){
ReflectServiceImp2 object = null;
try{
object = (ReflectServiceImp2)
Class.forName("com.lean.ssm.chapter2.reflect.ReflectServiceImp2").getConstructor(String.class).newInstance("张三");
}catch (ClassNotFoundException | InstantiationException
| IllegalAccessException | NoSuchMethodException
| SecurityException | IllegalArgumentException
| InvocationTargetException e){
e.printStackTrace();
}
return object;
}
}
2、反射方法
以ReflectServiceImp1为例子:
public Object reflectMethod(){
Object returnObj = null;
ReflectServiceImp1 target = new ReflectServiceImp1();
try{
Method method = ReflectServiceImp1.class.getMethod("sayHello", String.class);
returnObj = method.invoke(target, "张三");
}catch (NoSuchMethodException | SecurityException
| IllegalArgumentException | IllegalAccessException
| InvocationTargetException e){
e.printStackTrace();
}
return returnObj;
}
其中,可以或许构造方法,方法,甚至是成员对象,有需要可以到网上查阅.
动态代理模式和责任链模式
动态代理意义在于生成一个代理对象(又称占位),来代理真实对象,从而控制真实对象的访问。
就比如,我是一个软件工程师,根据需求我写了一个类,类中有一个方法,我不必要去管这个方法执行与否,我只需要交给一个代理,让他去判断。
代理必须分为两个步骤:
- 代理对象和真实对象之间建立代理关系
- 实现代理对象的代理逻辑方法(判断一个方法的执行)
Java中有多种动态代理技术,这里只讨论JDK和CGLIB
1、JDK动态代理
JDK动态代理是java.lang.reflect.*种提供的方式,必须实现一个接口才能产生代理对象,所以先定义接口,如下:
public interface HelloWorld{
public void sayHello();
}
然后提供实现类HelloWorldImp1:
package com.lean.ssm.chapter2.reflect.proxy;
public class HelloWorldImp1 implements HelloWorld{
@Override
public void sayHello() {
System.out.println("Hello World");
}
}
开始实现代理逻辑,一共分为两个步骤,在JDK动态代理中,实现代理逻辑类必须实现java.lang.reflect.InvocationHandler接口,里面定义了一个invoke方法,并提供接口数据用于下挂代理对象:
package com.lean.ssm.chapter2.reflect.proxy;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
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);
}
/**
* 代理方法逻辑
* @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); //相当于调用sayHelloWorld方法
System.out.println("在调度真实对象之后的服务");
return obj;
}
public static void testJdkProxy(){
JdkProxyExample jdk = new JdkProxyExample();
//绑定关系,因为挂在接口HelloWorld下,所以声明代理对象HelloWorld proxy
HelloWorld proxy = (HelloWorld)jdk.bind(new HelloWorldImp1());
// 此时HelloWorld 已经是一个代理对象,他会进入代理的逻辑方法invoke中
proxy.sayHello();
}
public static void main(String[] args){
testJdkProxy();
}
}
第一步,建立代理对象和真实对象的关系,通过bind方法去完成。
其中,newProxyInstance包含了三个参数
- 第1个是类加载器,传入target本身的类加载器
- 第2个是把生成的动态代理对象挂在哪些接口下,这个写法就是放在target实现的接口下
- 第3个是定义实现方法逻辑的代理类(必须实现InvocationHandler接口的invoke方法。
第二步,实现代理逻辑方法invoke,invoke方法的参数含义如下 - proxy,代理对象,就是bind方法生成的对象
- method 当前调度的方法
- args 调度的方法的参数
当代理调用一个方法的时候,会进入这个invoke方法中,处理逻辑,可以选择执行方法或者不执行方法。
//代表着调度真实对象的方法
Object obj = method.invoke(target, args);
2、CGLIB动态代理
CGLIB动态代理是第三方包,必须先下载CGLIB包并且导入。
JDK动态代理必须提供接口才能使用(HelloWorld),在一些不能使用接口的环境中,就只能采取第三方代理技术,入CGLIB。
package com.lean.ssm.chapter2.reflect.proxy;
import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
import java.lang.reflect.Method;
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 方法参数
* @param methodProxy 方法代理
* @return 代理逻辑返回
* @throws Throwable
*/
@Override
public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
System.out.println("调用真实对象前");
//CGLIB反射调用真实对象方法
Object result = methodProxy.invokeSuper(proxy, args);
System.out.println("调用真实对象后");
return result;
}
public static void testCGLIBProxy(){
CglibProxyExample cpe = new CglibProxyExample();
ReflectServiceImp1 obj = (ReflectServiceImp1)cpe.getProxy(ReflectServiceImp1.class);
obj.sayHello("张三");
}
public static void main(String[] args){
testCGLIBProxy();
}
}
这里使用了CGLIB的加强者Enhancer,通过设置超类的方法(setSuperClass),然后通过setCallback设置哪个类为它的代理类(setSuperClass),参数this是当前对象,必须实现MethodInterceptor方法 —— intercept,然后返回代理对象
3、拦截器
由于动态代理一般比较难理解,程序设计者会设计一个拦截器接口提供开发者使用,开发者只需要知道拦截器的方法、含义、作用就可以了,不需要管动态代理怎么实现的,首先,实现一个拦截器的逻辑:
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);
}
3个方法的参数为:
- proxy 代理对象
- target 真实对象
- method 方法
- args 方法参数
接口内方法的使用:
- before方法返回一个boolean值,如果为true,则反射真实对象的方法,如果false的时候,则调用around方法
- 在反射真实对象方法或者around方法时,调用after方法
package com.lean.ssm.chapter2.reflect.proxy;
import com.lean.ssm.chapter2.reflect.Interceptor;
import java.lang.reflect.Method;
public class MyInterceptor implements Interceptor {
@Override
public boolean before(Object proxy, Object target, Method method, Object[] args) {
System.out.println("反射方法前逻辑");
return false; // 不反射被代理对象原油方法
}
@Override
public void after(Object proxy, Object target, Method method, Object[] args) {
System.out.println("反射方法后逻辑");
}
@Override
public void around(Object proxy, Object target, Method method, Object[] args) {
System.out.println("取代了被代理对象的方法");
}
}
在JDK动态代理中使用拦截器:
package com.lean.ssm.chapter2.reflect.proxy;
import com.lean.ssm.chapter2.reflect.Interceptor;
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
* @param interceptorClass
* @return 代理占位
*/
public static Object bind(Object target, String interceptorClass){
return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(),
new InterceptorJdkProxy(target,interceptorClass));
}
@Override
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{
interceptor.around(proxy, target, method, args);
}
interceptor.after(proxy, target, method, args);
return result;
}
}
代码执行步骤:
- 在bind方法中用JDK动态代理绑定一个对象,然后返回代理对象
- 如果没有设置拦截器,则直接反射真实对象的方法,然后结束,否则进行第三步
- 通过反射生成拦截器,并准备使用
- 调用拦截器的before方法,如果返回的是true,反射原来的方法,否则运行around方法
- 调用拦截器的after方法
- 返回结果
测试:
public static void main(String[] args){
HelloWorld proxy = (HelloWorld) InterceptorJdkProxy.bind(new HelloWorldImp1(),
"com.lean.ssm.chapter2.interceptor.MyInterceptor");
proxy.sayHello();
}
会显示:
反射方法前逻辑
取代了被代理对象的方法(真实对象)
反射方法后逻辑
设计模式
1、责任链模式
当一个对象在一条链上被多个拦截器拦截处理,这样的设计模式称为责任链模式。
比如一个部门里面,提出请假,请假流程如下:
请假申请单 - 项目经理 - 部门经历- 人事部
这样,后面的审批都要经过前面的结果进行,这时候可以考虑层层代理:
请假单(target)走到项目经理处,生成第一个proxy1,当走到部门经理是,根据proxy1的基础生成proxy2,以此类推。
package com.lean.ssm.chapter2.reflect;
import java.lang.reflect.Method;
public class Interceptor1 implements Interceptor {
@Override
public boolean before(Object proxy, Object target, Method method, Object[] args) {
System.out.println("[拦截器1]的before方法");
return true;
}
@Override
public void around(Object proxy, Object target, Method method, Object[] args) {
// System.out.println("[拦截器1]的around方法");
}
@Override
public void after(Object proxy, Object target, Method method, Object[] args) {
System.out.println("[拦截器1]的after方法");
}
}
package com.lean.ssm.chapter2.reflect;
import java.lang.reflect.Method;
public class Interceptor2 implements Interceptor {
@Override
public boolean before(Object proxy, Object target, Method method, Object[] args) {
System.out.println("[拦截器2]的before方法");
return true;
}
@Override
public void around(Object proxy, Object target, Method method, Object[] args) {
// System.out.println("[拦截器2]的around方法");
}
@Override
public void after(Object proxy, Object target, Method method, Object[] args) {
System.out.println("[拦截器2]的after方法");
}
}
package com.lean.ssm.chapter2.reflect;
import java.lang.reflect.Method;
public class Interceptor3 implements Interceptor{
@Override
public boolean before(Object proxy, Object target, Method method, Object[] args) {
System.out.println("[拦截器3]的before方法");
return true;
}
@Override
public void around(Object proxy, Object target, Method method, Object[] args) {
// System.out.println("[拦截器3]的around方法");
}
@Override
public void after(Object proxy, Object target, Method method, Object[] args) {
System.out.println("[拦截器3]的after方法");
}
}
public class Main {
public static void main(String[] args){
HelloWorld proxy1 = (HelloWorld) InterceptorJdkProxy.bind(new HelloWorldImp1(), "com.lean.ssm.chapter2.reflect.Interceptor1");
HelloWorld proxy2 = (HelloWorld) InterceptorJdkProxy.bind(proxy1, "com.lean.ssm.chapter2.reflect.Interceptor2");
HelloWorld proxy3 = (HelloWorld) InterceptorJdkProxy.bind(proxy2, "com.lean.ssm.chapter2.reflect.Interceptor3");
proxy3.sayHello();
}
}
运行代码,得出结果:
[拦截器3]的before方法
[拦截器2]的before方法
[拦截器1]的before方法
Hello World
[拦截器1]的after方法
[拦截器2]的after方法
[拦截器3]的after方法
2、观察者模式
在现实生活中,有些条件发生了变化,其他的行为也要发生变化,如果我们用if语句来应对,比如电商的平台,则是如下:
if(产品库有更新){
推送产品到淘宝;
推送产品到京东;
}
但是如果又增加了几个公司,那么又要修改if代码:
if(产品库有更新){
推送产品到淘宝;
推送产品到京东;
推动产品带公司x;
...
}
这样要不断修改if,所以if的逻辑就十分负责,如果淘宝出错,那么下一个都不会执行,于是有了观察者模式:
当一个可观察对象发生变化的时候,会通知观察者,观察者就根据情况做出逻辑判断
//被观察的产品列表
package com.lean.ssm.chapter2.reflect.Observable;
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 addProduct(String newProduct){
productList.add(newProduct);
System.out.println("产品列表新增了产品: " + newProduct);
this.setChanged();
this.notifyObservers(newProduct);
}
}
核心逻辑:addProduct(),当产品列表发生变化的时候,就调用setChanged方法告诉观察者对象当前被观察者发生了变化,如果没有,则不变化,最后通过notufyObservers告知观察者做出相应的动作。
package com.lean.ssm.chapter2.reflect.Observable;
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.out.println("发送新产品【" + newProduct + "】同步到京东商城");
}
}
package com.lean.ssm.chapter2.reflect.Observable;
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.out.println("发送新产品【" + newProduct + "】同步到淘宝商城");
}
}
package com.lean.ssm.chapter2.reflect.Observable;
public class Main {
public static void main(String[] args){
ProductList observable = ProductList.getInstance();
TaoBaoObserver taoBaoObserver = new TaoBaoObserver();
JingDongObserver jingDongObserver = new JingDongObserver();
observable.addObserver(jingDongObserver);
observable.addObserver(taoBaoObserver);
observable.addProduct("产品1");
}
}
运行main,得到如下结果:
产品列表新增了产品: 产品1
发送新产品【产品1】同步到淘宝商城
发送新产品【产品1】同步到京东商城