1 简单工厂模式
简介
- 定义一个工厂类,它可以根据参数的不同返回不同类的实例,被创建的实例具有共同的父类;
- 优点:(1)屏蔽产品的具体实现,调用者想创建一个对象,只要知道其名称即可;(2)扩展性高,如果想增加一个产品,只要增加一个实体类即可;
- 缺点:会增加系统中类的个数(引入新的工厂类),增加了系统的复杂度;
- 应用场景:数据库访问,用户不确定系统最终采用哪一类数据库;
实现
1 创建一个 Shape 接口
Shape.java
public interface Shape {
void draw();
}
2 创建若干实现 Shape 接口的实体类
Rectangle.java
public class Rectangle implements Shape {
@Override
public void draw() {
System.out.println("Inside Rectangle::draw() method.");
}
}
Square.java
public class Square implements Shape {
@Override
public void draw() {
System.out.println("Inside Square::draw() method.");
}
}
Circle.java
public class Circle implements Shape {
@Override
public void draw() {
System.out.println("Inside Circle::draw() method.");
}
}
3 创建工厂类 ShapeFactory,ShapeFactory内部定义函数Shape getShape(String shapeType)用于返回基于给定信息的实体类对象
ShapeFactory.java
public class ShapeFactory {
//使用 getShape 方法获取形状类型的对象
public Shape getShape(String shapeType){
if(shapeType == null){
return null;
}
if(shapeType.equalsIgnoreCase("CIRCLE")){
return new Circle();
} else if(shapeType.equalsIgnoreCase("RECTANGLE")){
return new Rectangle();
} else if(shapeType.equalsIgnoreCase("SQUARE")){
return new Square();
}
return null;
}
}
4 创建工厂对象,通过传递类型信息来获取实体类的对象
FactoryPatternDemo.java
public class FactoryPatternDemo {
public static void main(String[] args) {
ShapeFactory shapeFactory = new ShapeFactory();
//获取 Circle 的对象,并调用它的 draw 方法
Shape shape1 = shapeFactory.getShape("CIRCLE");
//调用 Circle 的 draw 方法
shape1.draw();
//获取 Rectangle 的对象,并调用它的 draw 方法
Shape shape2 = shapeFactory.getShape("RECTANGLE");
//调用 Rectangle 的 draw 方法
shape2.draw();
//获取 Square 的对象,并调用它的 draw 方法
Shape shape3 = shapeFactory.getShape("SQUARE");
//调用 Square 的 draw 方法
shape3.draw();
}
}
Inside Circle::draw() method.
Inside Rectangle::draw() method.
Inside Square::draw() method.
2 单例模式
简介
- 确保类仅有一个实例,并提供一个访问它的全局访问点。
- 应用场景:许多时候系统只需要拥有一个全局对象,这有利于我们协调系统整体的行为。比如在某个服务器程序中,该服务器的配置信息存放在一个文件中,这些配置数据由一个单例对象统一读取,然后服务进程中的其他对象再通过这个单例对象获取这些配置信息,如此就简化了在复杂环境下的配置管理。
实现一:饿汉式
是否懒初始化:否
是否多线程安全:是
描述:优点:没有加锁,执行效率高;缺点:类加载时就初始化,浪费内存。
它基于 classloader 机制避免了多线程的同步问题,不过,instance在类装载时就实例化,虽然导致类装载的原因有很多种,在单例模式中大多数都是调用 getInstance 方法,但是也不能确定有其他的方式(或者其他的静态方法)导致类装载,这时候初始化 instance 显然没有达到 lazy loading 的效果。
public class Singleton {
private static Singleton instance = new Singleton();
private Singleton (){}
public static Singleton getInstance() {
return instance;
}
}
实现二:双重校验锁的懒汉式
是否懒初始化:是
是否多线程安全:是
描述:采用synchronized+volatile,实现了懒初始化、线程安全且能保持高性能。
public class Singleton {
private volatile static Singleton instance;
private Singleton (){}
public static Singleton getSingleton() {
if (instance == null) {
synchronized (Singleton.class) {
if (instance == null) {
instance = new Singleton();
}
}
}
return instance;
}
}
3 备忘录模式
简介
- 在不破坏封装的前提下,捕获一个对象的内部状态,并在该对象之外保存这个状态,这样可以在以后将对象恢复到原先保存的状态;
- 应用场景:Windows 里的 ctrl + z ,PS里的快照;
实现
1 创建Memento(备忘录)类
Memento.java
public class Memento {
private String state;
public Memento(String state){
this.state = state;
}
public String getState(){
return state;
}
}
2 创建Originator(发起者) 类
Originator.java
public class Originator {
private String state;
public void setState(String state){
this.state = state;
}
public String getState(){
return state;
}
public Memento saveStateToMemento(){
return new Memento(state);
}
public void getStateFromMemento(Memento Memento){
state = Memento.getState();
}
}
3 创建 CareTaker(管理员) 类
CareTaker.java
public class CareTaker {
private List<Memento> mementoList = new ArrayList<>();
public void add(Memento state){
mementoList.add(state);
}
public Memento get(int index){
return mementoList.get(index);
}
}
4 使用Originator(发起者) 和CareTaker(管理员) 对象
MementoPatternDemo.java
public class MementoPatternDemo {
public static void main(String[] args) {
Originator originator = new Originator();
CareTaker careTaker = new CareTaker();
originator.setState("State #1");
originator.setState("State #2");
careTaker.add(originator.saveStateToMemento());
originator.setState("State #3");
careTaker.add(originator.saveStateToMemento());
originator.setState("State #4");
System.out.println("Current State: " + originator.getState());
originator.getStateFromMemento(careTaker.get(0));
System.out.println("First saved State: " + originator.getState());
originator.getStateFromMemento(careTaker.get(1));
System.out.println("Second saved State: " + originator.getState());
}
}
Current State: State #4
First saved State: State #2
Second saved State: State #3
4 MVC模式
简介
- 即Model-View-Controller(模型-视图-控制器) 模式,这种模式用于应用程序的分层开发;
- Model(模型):代表一个存取数据的对象或JAVA POJO;
- View(视图):代表模型包含的数据的可视化;
- Controller(控制器):作用于模型和视图上,它控制数据流向模型对象,并在数据变化时更新视图。它使视图与模型分离开;
- 应用场景:1 Web 项目的开发中,用户在网页上单击一个 URL 路径,这对 Web 服务器来说,相当于用户发送了一个请求。而获取请求后如何解析用户的输入,并执行相关处理逻辑,最终跳转至正确的页面显示反馈结果,这些工作往往是控制层(Controller)来完成的;2 在请求的过程中,用户的信息被封装在 User 实体类中,该实体类在 Web 项目中属于数据模型层(Model);3 在请求显示阶段,跳转的结果网页就属于视图层(View);4 像这样,控制层负责前台与后台的交互,数据模型层封装用户的输入/输出数据,视图层选择恰当的视图来显示最终的执行结果,这样的层次分明的软件开发和处理流程被称为 MVC 模式;5 在学习 Servlet 及 JSP 开发时,JavaBean 相当于 Model,Servlet 相当于 Controller,JSP 相当于 View;
实现
Student作为模型类;StudentView作为视图类,把学生详细信息输出到控制台;StudentController作为控制器类,负责控制数据流向Student对象,并相应地更新视图。
1 创建Model(模型)
Student.java
public class Student {
private String rollNo;
private String name;
public String getRollNo() {
return rollNo;
}
public void setRollNo(String rollNo) {
this.rollNo = rollNo;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
2 创建View(视图)
StudentView.java
public class StudentView {
public void printStudentDetails(String studentName, String studentRollNo){
System.out.println("Student: ");
System.out.println("Name: " + studentName);
System.out.println("Roll No: " + studentRollNo);
}
}
3 创建Controller(控制器)
StudentController.java
public class StudentController {
private Student model;
private StudentView view;
public StudentController(Student model, StudentView view){
this.model = model;
this.view = view;
}
public void setStudentName(String name){
model.setName(name);
}
public String getStudentName(){
return model.getName();
}
public void setStudentRollNo(String rollNo){
model.setRollNo(rollNo);
}
public String getStudentRollNo(){
return model.getRollNo();
}
public void updateView(){
view.printStudentDetails(model.getName(), model.getRollNo());
}
}
4 使用 Controller 中的方法
MVCPatternDemo.java
public class MVCPatternDemo {
public static void main(String[] args) {
//从数据库获取学生记录
Student model = retrieveStudentFromDatabase();
//创建一个视图:把学生详细信息输出到控制台
StudentView view = new StudentView();
StudentController controller = new StudentController(model, view);
controller.updateView();
//更新模型数据
controller.setStudentName("John");
controller.updateView();
}
private static Student retrieveStudentFromDatabase(){
Student student = new Student();
student.setName("Robert");
student.setRollNo("10");
return student;
}
}
Student:
Name: Robert
Roll No: 10
Student:
Name: John
Roll No: 10
5 代理模式
代理模式提供了对目标对象额外的访问方式,即通过代理对象访问目标对象,这样可以在不修改原目标对象的前提下,提供额外的功能操作,扩展目标对象的功能。
简言之,代理模式就是设置一个中间代理来控制访问原目标对象,以达到增强原对象的功能和简化访问方式。
5.1 静态代理
静态代理方式需要代理对象和目标对象实现一样的接口。
优点:可以在不修改目标对象的前提下扩展目标对象的功能。
缺点:1 冗余。由于代理对象要实现与目标对象一致的接口,会产生过多的代理类;2 不易维护。一旦接口增加方法,目标对象与代理对象都要进行修改;
案例:
1 接口类: IUserDao
package com.proxy;
public interface IUserDao {
public void save();
}
2 目标对象:UserDao,需要实现IUserDao接口
package com.proxy;
public class UserDao implements IUserDao {
@Override
public void save() {
System.out.println("保存数据");
}
}
3 静态代理对象:UserDapProxy,需要实现IUserDao接口
package com.proxy;
public class UserDaoProxy implements IUserDao{
private IUserDao target;
public UserDaoProxy(IUserDao target) {
this.target = target;
}
@Override
public void save() {
System.out.println("开启事务");//扩展了额外功能
target.save();
System.out.println("提交事务");
}
}
4 测试类:TestProxy
package com.proxy;
import org.junit.Test;
public class StaticUserProxy {
@Test
public void testStaticProxy(){
//目标对象
IUserDao target = new UserDao();
//代理对象
UserDaoProxy proxy = new UserDaoProxy(target);
proxy.save();
}
}
开启事务
保存数据
提交事务
5.2 动态代理
动态代理利用了JDK API,在运行时动态地构建代理对象。
静态代理与动态代理的区别:
- 静态代理在编译时就已经生成,编译完成后代理类是一个实际的class文件;
- 动态代理在运行时动态生成,即编译完成后没有实际的class文件,而是在运行时动态生成class文件,并加载到JVM中;
- 静态代理要求目标对象和代理对象都实现接口;动态代理对象不要求实现接口,但要求目标对象必须实现接口。
JDK中生成代理对象主要涉及的类有
- java.lang.reflect.Proxy,主要方法为
//返回一个指定接口的代理类实例,该接口可以将方法调用指派到指定的调用处理程序。
static Object newProxyInstance(
ClassLoader loader, //指定当前目标对象使用的类加载器
Class<?>[] interfaces, //目标对象实现的接口的类型
InvocationHandler h //事件处理器
)
- java.lang.reflect.InvocationHandler,主要方法为
Object invoke(Object proxy, Method method, Object[] args) // 在代理实例上处理方法调用并返回结果。
案例:
1 接口类: IUserDao
package com.proxy;
public interface IUserDao {
public void save();
}
2 目标对象:UserDao,需要实现IUserDao接口
package com.proxy;
public class UserDao implements IUserDao{
@Override
public void save() {
System.out.println("保存数据");
}
}
3 动态代理对象:UserProxyFactory,不需要实现IUserDao接口
package com.proxy;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
public class UserProxyFactory {
private Object target;// 维护一个目标对象
public UserProxyFactory(Object target) {
this.target = target;
}
// 为目标对象生成代理对象
public Object getProxyInstance() {
return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(),
new InvocationHandler() {
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("开启事务");
// 执行目标对象方法
Object returnValue = method.invoke(target, args);
System.out.println("提交事务");
return returnValue;
}
}
);
}
}
4 测试类:TestProxy
package com.proxy;
import org.junit.Test;
public class TestProxy {
@Test
public void testDynamicProxy (){
IUserDao target = new UserDao();
System.out.println(target.getClass()); //输出目标对象信息
IUserDao proxy = (IUserDao) new UserProxyFactory(target).getProxyInstance();
System.out.println(proxy.getClass()); //输出代理对象信息
proxy.save(); //执行代理方法
}
}
class com.proxy.UserDao
class com.sun.proxy.$Proxy4
开启事务
保存数据
提交事务