1.定义
指一个类只有一个实例，且该类能自行创建这个实例的一种模式。
2.特点
1. 单例类只有一个实例对象；
2. 该单例对象必须由单例类自行创建；
3. 单例类对外提供一个访问该单例的全局访问点。
- 单例类：包含一个实例且能自行创建这个实例的类。
- 访问类：使用单例的类。
Singleton 模式的两种实现形式 懒汉式单例该模式的特点是类加载时没有生成单例，只有当第一次调用 getlnstance 方法时才去创建这个单例。
public class LazySingleton {
//保证 instance 在所有线程中同步
private static volatile LazySingleton instance = null;
//private 避免类在外部被实例化
private LazySingleton() {}
//双重检测锁模式的 懒汉式单例 DCL懒汉式→→→
public static synchronized LazySingleton getInstance() {
//getInstance 方法前加同步
if (instance == null) {
instance = new LazySingleton();
}
return instance;
}
}
注意：如果编写的是多线程程序，则不要删除上例代码中的关键字 volatile 和 synchronized，否则将存在线程非安全的问题。如果不删除这两个关键字就能保证线程安全，但是每次访问时都要同步，会影响性能，且消耗更多的资源，这是懒汉式单例的缺点。
饿汉式单例该模式的特点是类一旦加载就创建一个单例，保证在调用 getInstance 方法之前单例已经存在了。
public class HungrySingleton {
private static final HungrySingleton instance = new HungrySingleton();
private HungrySingleton() {
}
public static HungrySingleton getInstance() {
return instance;
}
}
饿汉式单例在类创建的同时就已经创建好一个静态的对象供系统使用，以后不再改变，所以是线程安全的，可以直接用于多线程而不会出现问题
应用场景- 需要频繁创建的一些类，使用单例可以降低系统的内存压力，减少 GC。
- 某类只要求生成一个对象的时候，如一个班中的班长、每个人的身份证号等。
- 某些类创建实例时占用资源较多，或实例化耗时较长，且经常使用。
- 某类需要频繁实例化，而创建的对象又频繁被销毁的时候，如多线程的线程池、网络连接池等。
- 频繁访问数据库或文件的对象。
- 对于一些控制硬件级别的操作，或者从系统上来讲应当是单一控制逻辑的操作，如果有多个实例，则系统会完全乱套。
- 当对象需要被共享的场合。由于单例模式只允许创建一个对象，共享该对象可以节省内存，并加快对象访问速度。如 Web 中的配置对象、数据库的连接池等。
总结
核心作用
保证一个类只有一个实例，并且提供一个访问该实例的全局访问点
优点
- 单例模式可以保证内存里只有一个实例，减少了内存的开销。
- 可以避免对资源的多重占用。
- 单例模式设置全局访问点，可以优化和共享资源的访问。
缺点
- 单例模式一般没有接口，扩展困难。如果要扩展，则除了修改原来的代码，没有第二种途径，违背开闭原则。
- 在并发测试中，单例模式不利于代码调试。在调试过程中，如果单例中的代码没有执行完，也不能模拟生成一个新的对象。
- 单例模式的功能代码通常写在一个类中，如果功能设计不合理，则很容易违背单一职责原则。
用来生产同一等级结构中的任意产品（对于新增产品，需要扩展已有代码）
虽然某种程度上不符合设计原则，但实际使用最多
工厂方法模式（Factory Method）用来生产同一等级结构中的固定产品（支持增加任意产品）
抽象工厂（AbstractFactory）模式
抽象工厂模式是提供了一个创建一系列相关或相互依赖对象的接口，且访问类无须指定所要产品的具体类就能得到同族的不同等级的产品的模式结构。
优点
具体产品在应用层的代码隔离，无需关心创建的细节
将一个系列的产品统一到一起创建
缺点
规定了所有可能被创建的产品集合，产品簇中扩展新的产品困难
增加了相同的抽象性和理解难度
模式的结构
1. 抽象工厂（Abstract Factory）：提供了创建产品的接口，它包含多个创建产品的方法 newProduct()，可以创建多个不同等级的产品。
2. 具体工厂（Concrete Factory）：主要是实现抽象工厂中的多个抽象方法，完成具体产品的创建。
3. 抽象产品（Product）：定义了产品的规范，描述了产品的主要特性和功能，抽象工厂模式有多个抽象产品。
4. 具体产品（ConcreteProduct）：实现了抽象产品角色所定义的接口，由具体工厂来创建，它同具体工厂之间是多对一的关系。
适用场景
客户端（应用层）不依赖于产品实例如何被创建、实现等细节
强调一系列相关的产品对象（属于同一产品族）一起使用创建对象需要大量的重复代码
提供一个产品类的库，所有产品以同样的接口出现，从而使客户端不依赖于具体的实现
//抽象产品工厂
public interface MyProductFactory {
//生产
MyPhoneProduct phoneProduct();
MyRouteProduct routerProduct();
}
public interface MyPhoneProduct {
void start();
void shutDown();
void call();
void sendMessage();
}
public interface MyRouteProduct {
void start();
void shutDown();
void openWife();
void setting();
}
public class HuaWeiFactory implements MyProductFactory {
@Override
public MyPhoneProduct phoneProduct() {
return new HuaWei();
}
@Override
public MyRouteProduct routerProduct() {
return new HuaWeiRouter();
}
}
public class HuaWei implements MyPhoneProduct{
@Override
public void start() {
System.out.println("打开华为手机");
}
@Override
public void shutDown() {
System.out.println("关闭华为手机");
}
@Override
public void call() {
System.out.println("华为手机打电话");
}
@Override
public void sendMessage() {
System.out.println("华为手机发短信");
}
}
public class HuaWeiRouter implements MyRouteProduct {
@Override
public void start() {
System.out.println("启动华为路由器");
}
@Override
public void shutDown() {
System.out.println("关闭华为路由器");
}
@Override
public void openWife() {
System.out.println("打开华为wife");
}
@Override
public void setting() {
System.out.println("设置华为路由器");
}
}
public class Client {
public static void main(String[] args) {
System.out.println("-----huawei系列-----");
HuaWeiFactory hw = new HuaWeiFactory();
MyPhoneProduct myPhoneProduct = hw.phoneProduct();
myPhoneProduct.call();
myPhoneProduct.sendMessage();
MyRouteProduct myRouteProduct = hw.routerProduct();
myRouteProduct.openWife();
myRouteProduct.start();
}
}
三、代理模式
静态代理
角色分析
抽象角色：一般会使用接口或抽象类来解决
真实角色：被代理的角色
代理角色：代理真实角色，代理角色后，我们一般会做一些附属操作
客户：访问代理对象的人
代码步骤
接口
真实角色
代理角色
客户端访问代理角色
优点
可以使真实角色的操作更加纯粹，不用去关注一些公共的业务
公共业务就交给代理角色，实现了业务的分工
公共业务发生扩展的时候，方便集中管理
缺点
一个真实角色就会产生一个代理角色；代码量会翻倍~开发效率会变低
public interface UserService {
public void add();
public void delete();
public void update();
public void query();
}
public class UserServiceProxy implements UserService {
private UserServiceImpl userService;
public UserServiceProxy(UserServiceImpl userService) {
this.userService = userService;
}
@Override
public void add() {
log("add");
userService.add();
}
@Override
public void delete() {
log("delete");
userService.delete();
}
@Override
public void update() {
log("update");
userService.update();
}
@Override
public void query() {
log("query");
userService.query();
}
//日志方法
public void log(String msg) {
System.out.println("使用了" + msg + "方法");
}
}
public class UserServiceImpl implements UserService {
@Override
public void add() {
System.out.println("添加了一个用户");
}
@Override
public void delete() {
System.out.println("删除了一个用户");
}
@Override
public void update() {
System.out.println("修改了一个用户");
}
@Override
public void query() {
System.out.println("查询了一个用户");
}
}
public class Client {
public static void main(String[] args) {
UserServiceImpl us = new UserServiceImpl();
UserServiceProxy usp = new UserServiceProxy(us);
usp.add();
}
}
动态代理
概述：在程序运行时，运用反射机制动态创建而成。
特点：
- 动态代理和静态代理角色一样
- 动态代理的代理类是动态生成的，不是我们直接写好的
- 动态代理分为两大类：基于接口的动态代理、基于类的动态代理
需要了解两个类：Proxy 代理，InvocationHandler 调用处理程序
//用这个类自动生成代理类
public class ProxyInvocationHandler implements InvocationHandler {
//被代理的接口
private Object target;
public void setTarget(Object target) {
this.target = target;
}
//生成得到代理类
public Object getProxy() {
return Proxy.newProxyInstance(this.getClass().getClassLoader(), target.getClass().getInterfaces(), this);
}
//处理代理实例，并返回结果
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
//
// log(method.getName());
//动态代理的本质就是使用反射机制实现
return method.invoke(target, args);
}
public void log(String msg){
System.out.println("实现了"+msg+"方法");
}
}
动态代理的代理类是动态生成的，不是我们直接写好的
