让我们携手进入java设计模式~_java addproudct-CSDN博客

本文链接：https://blog.csdn.net/h_r_f/article/details/80609760

一、 java反射技术
1、通过反射构建对象
法一：
package com.hrf.reflect;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

public class ReflectServiceImpl {
public static void main(String[] args){
System.out.println(new ReflectServiceImpl().getInstance());
}
//反射构建对象
public ReflectServiceImpl getInstance(){
ReflectServiceImpl object=null;
try {
object=(ReflectServiceImpl) Class.forName("com.hrf.reflect.ReflectServiceImpl").newInstance();
} catch (InstantiationException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IllegalAccessException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return object;
}

public void sayHello(String name){
System.out.println("Hello "+name);
}

}

控制台输出：
com.hrf.reflect.ReflectServiceImpl@7852e922

法二：

package com.hrf.reflect;

import java.lang.reflect.InvocationTargetException;

public class ReflectServiceImpl2 {
private String name;
public ReflectServiceImpl2(String name){
this.name=name;
}

public static void main(String[] args) {
// TODO Auto-generated method stub
System.out.println(new ReflectServiceImpl2("hhh").getInstance());
}

//反射构建对象
public ReflectServiceImpl2 getInstance(){
ReflectServiceImpl2 object=null;
try {
//先通过forName加载到类的加载器，然后通过getConstructor方法，它的参数可以是多个，这里定义为String.class,意为只有一个参数类型为string的构建方法。
object=(ReflectServiceImpl2) Class.forName("com.hrf.reflect.ReflectServiceImpl2").getConstructor(String.class).newInstance("hrf");
} catch (InstantiationException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IllegalAccessException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IllegalArgumentException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (InvocationTargetException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (NoSuchMethodException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (SecurityException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return object;
}
public void sayHello(String name){
System.out.println("Hello "+name);
}
}
控制台输出：
com.hrf.reflect.ReflectServiceImpl2@7852e922

2、反射方法
package com.hrf.reflect;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

public class ReflectServiceImpl {

public static void main(String[] args){
System.out.println(new ReflectServiceImpl().reflectMethod());
System.out.println(new ReflectServiceImpl().reflectMethod2());
}
// 法一：反射方法
public Object reflectMethod(){
Object returnObj=null;
ReflectServiceImpl target=new ReflectServiceImpl();
try {
Method method=ReflectServiceImpl.class.getMethod("sayHello",String.class);
try {
returnObj=method.invoke(target, "hrf");
} catch (IllegalAccessException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IllegalArgumentException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (InvocationTargetException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
} catch (NoSuchMethodException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (SecurityException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return returnObj+"123";
}

// 法二：反射方法
public Object reflectMethod2(){
ReflectServiceImpl target=null;
try {
try {
target=(ReflectServiceImpl) Class.forName("com.hrf.reflect.ReflectServiceImpl").newInstance();
} catch (InstantiationException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
} catch (IllegalAccessException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
} catch (ClassNotFoundException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
}
Method method=target.getClass().getMethod("sayHello",String.class);
try {
method.invoke(target, "hsd");
} catch (IllegalAccessException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IllegalArgumentException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (InvocationTargetException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
} catch (NoSuchMethodException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (SecurityException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return target;
}
public void sayHello(String name){
System.out.println("Hello "+name);
}
}

控制台输出：
Hello hrf
null123
Hello hsd
com.hrf.reflect.ReflectServiceImpl@7852e922

二、动态代理模式和责任链模式
1、动态代理模式
（1） Jdk动态代理
package com.hrf.proxy;
public interface HelloWorld {
public void sayHelloWorld();
}

package com.hrf.proxy;

public class HelloWorldImpl implements HelloWorld {
@Override
public void sayHelloWorld() {
System.out.println("Hello World");
}
}

package com.hrf.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;
}
}

package com.hrf.proxy;

import com.hrf.reflect.ReflectServiceImpl;

public class ProxyTest {

public static void main(String[] args) {
testJdkProxy();
}

public static void testJdkProxy() {
JdkProxyExample jdk = new JdkProxyExample();
// 绑定关系，因为挂在接口HelloWorld下，所以声明代理对象HelloWorld proxy
HelloWorld proxy = (HelloWorld) jdk.bind(new HelloWorldImpl());
// 注意，此时HelloWorld对象已经是一个代理对象，它会进入代理的逻辑方法invoke里
proxy.sayHelloWorld();
}
}

控制台输出：
进入代理逻辑方法
在调度真实对象之前的服务
Hello World
在调度真实对象之后的服务

（2）cglib动态代理

package com.hrf.proxy;

import java.lang.reflect.Method;

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
* 方法参数
* @param methodProxy
* 方法代理
* @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;
}
}

package com.hrf.proxy;

import com.hrf.reflect.ReflectServiceImpl;

public class ProxyTest {

public static void main(String[] args) {
tesCGLIBProxy();
}

public static void tesCGLIBProxy() {
CglibProxyExample cpe = new CglibProxyExample();
ReflectServiceImpl obj = (ReflectServiceImpl)cpe.getProxy(ReflectServiceImpl.class);
obj.sayHello("张三");
}
}

控制台输出：
调用真实对象前
调用真实对象后
Hello 张三

2、拦截器

定义拦截器接口
package com.hrf.intercepter;

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.hrf.intercepter;

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("取代了被代理对象的方法");
}
}

在jdk动态代理中使用拦截器
package com.hrf.intercepter;

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;
}
}

测试MyInterceptor

package com.hrf.intercepter;

import com.hrf.proxy.HelloWorld;
import com.hrf.proxy.HelloWorldImpl;

public class TestInterceptor {
public static void main(String[] args) {
testInterceptor();
}

//拦截器
public static void testInterceptor() {
HelloWorld proxy = (HelloWorld) InterceptorJdkProxy.bind(new HelloWorldImpl(),
"com.hrf.intercepter.MyInterceptor");
proxy.sayHelloWorld();
}
}

控制台输出：
反射方法前逻辑
取代了被代理对象的方法
反射方法后逻辑。

3、责任链模式

package com.hrf.intercepter;

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.hrf.intercepter;

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.hrf.intercepter;

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.hrf.intercepter;

import com.hrf.proxy.HelloWorld;
import com.hrf.proxy.HelloWorldImpl;

public class TestInterceptor {
public static void main(String[] args) {
testChain();
}

//责任链模式
public static void testChain() {
HelloWorld proxy1 = (HelloWorld) InterceptorJdkProxy.bind(
new HelloWorldImpl(), "com.hrf.intercepter.Interceptor1");
HelloWorld proxy2 = (HelloWorld) InterceptorJdkProxy.bind(
proxy1, "com.hrf.intercepter.Interceptor2");
HelloWorld proxy3 = (HelloWorld) InterceptorJdkProxy.bind(
proxy2, "com.hrf.intercepter.Interceptor3");
proxy3.sayHelloWorld();
}
}

控制台输出：

【拦截器3】的before方法
【拦截器2】的before方法
【拦截器1】的before方法
Hello World
【拦截器1】的after方法
【拦截器2】的after方法
【拦截器3】的after方法

三、观察者（Observer）模式
被观察者列表
package com.hrf.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.hrf.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.hrf.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.hrf.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");
}
}

控制台输出：
产品列表新增了产品：新增产品1
发送新产品【新增产品1】同步到淘宝商城

发送新产品【新增产品1】同步到京东商城

四、普通工厂和抽象工厂
1、普通工厂模式
package com.hrf.factory;

/**
* 冰淇淋接口
*
*
*/
public interface IceCream {

/**
* taste 方法表明是哪种口味
*/
public void taste();
}

package com.hrf.factory;

/**
* 苹果口味的冰淇淋
*
*
*/
public class AppleIceCream implements IceCream {

@Override
public void taste() {
System.out.println("苹果口味的冰淇淋");
}

}

package com.hrf.factory;

/**
* 香蕉口味的冰淇淋
*
*
*/
public class BananaIceCream implements IceCream {

@Override
public void taste() {
System.out.println("香蕉口味的冰淇淋");
}

}

package com.hrf.factory;

/**
* 草莓口味的冰淇淋
*
*
*/
public class StrawberryIceCream implements IceCream {

@Override
public void taste() {
System.out.println("草莓口味的冰淇淋");
}

}

package com.hrf.factory;

/**
* 冰淇淋工厂类
*
*
*/
public class IceCreamFactory {

/**
* 生产冰淇淋的方法
* @param flavour 哪种口味
* @return
*/
public static IceCream produceIceCream(String flavour){

IceCream iceCream = null;
if(flavour.equals("banana")){
iceCream = new BananaIceCream();
}else if(flavour.equals("apple")){
iceCream = new AppleIceCream();
}else if(flavour.equals("strawberry")){
iceCream = new StrawberryIceCream();
}else {
throw new IllegalArgumentException("没有该口味");
}
return iceCream;
}
}

测试普通工厂模式

package com.hrf.factory;

/**
* 客户端示例
*
*
*/
public class Console {

public static void main(String[] args) {
IceCream cream1 = IceCreamFactory.produceIceCream("apple");
cream1.taste();

IceCream cream2 = IceCreamFactory.produceIceCream("strawberry");
cream2.taste();

IceCream cream3 = IceCreamFactory.produceIceCream("unkown");
cream3.taste();
}

}

控制台输出：
苹果口味的冰淇淋
草莓口味的冰淇淋
Exception in thread "main" java.lang.IllegalArgumentException: 没有该口味
at com.hrf.factory.IceCreamFactory.produceIceCream(IceCreamFactory.java:25)
at com.hrf.factory.Console.main(Console.java:17)

注意：此刻报的错为正常现象，是程序抛出的！！！

2、抽象工厂模式
package com.hrf.factory;

/**
* 苹果口味的冰淇淋工厂
*
*
*/
public class AppleIceCreamFactory extends IceCreamFactory {

protected IceCream produceIceCream() {
return new AppleIceCream();
}

}

package com.hrf.factory;

/**
* 香蕉口味的冰淇淋工厂
*
*
*/
public class BananaIceCreamFactory extends IceCreamFactory {

protected IceCream produceIceCream() {
return new BananaIceCream();
}

}

package com.hrf.factory;

/**
* 草莓口味的冰淇淋工厂
*
*
*/
public class StrawberryIceCreamFactory extends IceCreamFactory {
protected IceCream produceIceCream() {
// TODO 自动生成的方法存根
return new StrawberryIceCream();
}

}

测试抽象工厂模式
package com.hrf.factory;

/**
* 客户端示例
*
*
*/
public class Console1 {

public static void main(String[] args) {
// 要草莓味的冰淇淋
IceCream c1 = new StrawberryIceCreamFactory().produceIceCream();
c1.taste();

// 要香蕉味的冰淇淋
IceCream c2 = new BananaIceCreamFactory().produceIceCream();
c2.taste();
}

}

控制台输出：
草莓口味的冰淇淋
香蕉口味的冰淇淋

五、建造者（Builder）模式