Java Design Pattern
2020-12-13 02:17
标签：ssl 执行 发送 single 请求 === 名称 classType private ●Factory是什么： 工厂模式同单例模式一样，也是Java中最常用的设计模式之一，属于创建型模式，它提供了一种创建对象的最佳方式。能够根据要求调用者提供的信息为接口指定不同的实现类，降低耦合。 ●接口及其实现类： ●简单工厂 上代码每写一个一个实现类就要就要改工厂类的代码，很不方便。可以通过反射解决这一问题。 ●简单工厂（反射） 在面对初始化复杂的对象时。反射的代码会很长，且结构性差，可以为每个子类都写一个工厂方法 ●多个工厂方法 也可以将上面的方法改写成静态的，这样就可以不用new对象，直接通过类名调用工厂方法了。 ●Singleton: 原型模式虽然是创建型的模式，但是与工程模式没有关系，从名字即可看出，该模式的思想就是将一个对象作为原型，对其进行复制、克隆，产生一个和原对象类似的新对象。本小结会通过对象的复制，进行讲解。在Java中，复制对象是通过clone()实现的，先创建一个原型类： 很简单，一个原型类，只需要实现Cloneable接口，覆写clone方法，此处clone方法可以改成任意的名称，因为Cloneable接口是个空接口，你可以任意定义实现类的方法名，如cloneA或者cloneB，因为此处的重点是super.clone()这句话，super.clone()调用的是Object的clone()方法，而在Object类中，clone()是native的，具体怎么实现，我会在另一篇文章中，关于解读Java中本地方法的调用，此处不再深究。在这儿，我将结合对象的浅复制和深复制来说一下，首先需要了解对象深、浅复制的概念： 浅复制：将一个对象复制后，基本数据类型的变量都会重新创建，而引用类型，指向的还是原对象所指向的。 深复制：将一个对象复制后，不论是基本数据类型还有引用类型，都是重新创建的。简单来说，就是深复制进行了完全彻底的复制，而浅复制不彻底。 动态代理（运行期行为）主要有一个 Proxy类 和一个 InvocationHandler接口 动态代理角色： 1. 抽象主题角色 2. 真实主题角色（实现了抽象主题接口） 3. 动态代理主题角色（实现了 InvocationHandler接口，并实现了 invoke()方法） Proxy 要调用 newProxyInstance方法 代码演示： 1.抽象主题角色 SubjectDemo.java 2. 真实主题角色 RealSubjectDemo.java 3. 动态代理主题角色 DynamicProxySubjectDemo.java 4.客户端 Client.java Java Design Pattern 标签：ssl 执行 发送 single 请求 === 名称 classType private 原文地址：https://www.cnblogs.com/railgun1/p/11031026.htmlpackage factory;
public interface Sender {
public void send();
}
package factory;
public class SmsSender implements Sender{
@Override
public void send() {
System.out.println("用短信发送...");
}
}
package factory;
public class EmailSender implements Sender{
@Override
public void send() {
System.out.println("用电子邮箱发送...");
}
package factory;
/**
* 普通工厂模式，可以需求生产对象
* 缺点：面对复杂的初始化，会使代码变得巨大
* 每添加一个实现类都要修改代码，违反了里氏替换原则
* 可能会产生null对象，引发 空指针异常
* @author wqj24
*
*/
public class GeneraSenderFactory {
public Sender produceSender(String msg) {
// 根据消息，指定具体实现类
if ("email".equals(msg)) {
return new EmailSender();
}
if ("sms".equals(msg)) {
return new SmsSender();
}
// 没有符合要求的产品
return null;
}
}
package factory;
/**
* 简单工厂的优化
* 优点：使用反射，避免了添加子类就要修改工厂对象
*/
public class GeneraSenderFactory01 {
public Sender produceSender(Class extends Sender> clazz) {
Sender sender = null;
try {
sender = (Sender) clazz.newInstance();
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
}
return sender;
}
}package factory;
/**
* 多工厂，每个方法负责生产各自的实例 优点可以应对复杂的初始化
* 优点：不会产生 null 对象
* 每个方法负责自己对象的初始化工作，结构清晰。
*/
public class ManySenderFactory {
public Sender produceEmail() {
return new EmailSender();
}
public Sender produceSms() {
return new SmsSender();
}
}
package com.singleton;
//静态代码块不一定在最开始执行，比如说 静态代码块 放在 单例模式中，
//但一般情况下 静态代码块是第一执行的 也就是在类加载时执行， 只执行一次
class SingletonTest
{
private static SingletonTest singletonTest = new SingletonTest();
static
{
System.out.println("======java 静态代码块========");
}
private SingletonTest()
{
System.out.println("java实现单例模式");
}
public static SingletonTest getInstance()
{
return singletonTest;
}
}
public class Singleton
{
public static void main(String[] args)
{
SingletonTest st = SingletonTest.getInstance();
SingletonTest st2 = SingletonTest.getInstance();
//返回true，这两个实例是一样的
System.out.println(st == st2);
}
prototype:
public class Prototype implements Cloneable {
public Object clone() throws CloneNotSupportedException {
Prototype proto = (Prototype) super.clone();
return proto;
}
}
proxy:
package com.dynamicproxy ;
public interface SubjectDemo
{
public void request() ;
}
package com.dynamicproxy ;
public class RealSubjectDemo implements SubjectDemo
{
public void request()
{
System.out.println("实现了某请求") ;
}
}
package com.dynamicproxy ;
import java.lang.reflect.InvocationHandler ;
import java.lang.reflect.Method ;
public class DynamicProxySubjectDemo implements InvocationHandler
{
private Object sub ;
public DynamicProxySubjectDemo(Object obj)
{
this.sub = obj ;
}
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable
{
System.out.println("before"+method) ;
method.invoke(sub, args) ;//真实的调用方法操作
System.out.println("after"+method) ;
return null ;
}
}
package com.dynamicproxy ;
import java.lang.reflect.InvocationHandler ;
import java.lang.reflect.Proxy ;
public class Client
{
public static void main(String[] args)
{
RealSubjectDemo rsd = new RealSubjectDemo() ;
InvocationHandler handler = new DynamicProxySubjectDemo(rsd) ;
Class> classType = handler.getClass() ;
// classType.getClassLoader() 动态代理类的类加载器
//rsd.getClass().getInterfaces() 代理类要实现的接口列表
//handler 指派方法调用的调用处理程序
SubjectDemo sd = (SubjectDemo)Proxy.newProxyInstance(classType.getClassLoader(), rsd.getClass().getInterfaces(), handler ) ;
//这行代码一执行 转到 InvocationHandler handler = new DynamicProxySubjectDemo(rsd)
//执行invoke方法
sd.request() ;
}
}