2020./08/18 小白学习之设计模式 QQ1017871939

            **

小白学习设计模式

为什么要学习设计模式，设计模式是经过很多程序员写多年代码和开发总结出来的方法，也俗称“”套路“”,学好设计模式有助于理解spring，也帮助你开发不走很多弯路，不再单纯是个码农。这就是java开发工程师的核心所在。

设计模式23种（不按顺利）

**

第一种 代理模式

**

**

代码实现
UserDao类

package com.uplooking.javase.ch08.demo06;

public interface UserDao {

	public void addUser();
	
	public void delUser();
	
}`

MyUserDao（目标类）

package com.uplooking.javase.ch08.demo06;

/**
 * 
 * @Description 被代理类（目标类）
 * @author Han.FM Email:191878893@qq.com
 * @version 
 * @date 2020年8月18日上午10:47:24
 *
 */
public class MyUserDao implements UserDao {

	@Override
	public void addUser() {
		System.out.println("添加用户...");
	}

	@Override
	public void delUser() {
		System.out.println("删除用户");
	}

}

MyUserDaoProxy （代理类）

package com.uplooking.javase.ch08.demo06;

/**
 * 
 * @Description 代理类(静态代理)
 * @author Han.FM Email:191878893@qq.com
 * @version 
 * @date 2020年8月18日上午10:46:59
 *
 */
public  class MyUserDaoProxy implements UserDao{
	/*
	 * 静态代理：
	 * 1、要求代理类和目标类实现相同的接口
	 * 2、在代理中中，要有一个目标类的实例
	 * 3、代理类中写代理方法
	 */
	// 目标类实例
	private UserDao userDao;
	
	public MyUserDaoProxy(UserDao userDao) {
		this.userDao = userDao;
	}

	@Override
	public void addUser() {
		log();
		userDao.addUser();
	}

	@Override
	public void delUser() {
		log();
		userDao.delUser();
	}
	
	private void log() {
		System.out.println("写日志....");
	}

}

单元测试代码

package com.uplooking.javase.ch08.demo06;

import org.junit.Test;

public class UserDaoTest {
	
	@Test
	public void test2() {
		
		 UserDao userDao = new MyUserDaoProxy(new MyUserDao());
		//UserDao userDao = new MyUserDao();
		
		userDao.addUser();
		userDao.delUser();
		
		// Spring 事务管理，用的就是代理模式（动态代理）
	}
	
	@Test
	public void test1() {
		UserDao userDao = new MyUserDao();
		
		userDao.addUser();
		
		userDao.delUser();
	}

}

设计模式的第二种 单例模式，也可是是饿汉模式、懒汉模式

**

代理类也就是相当于你的替身或者跑腿或者备份又或者中介。当你老板叫你添加工作日记的功能的时候，可以在代理类中new一个你的目标类，相当于代理类的方法加在你的目标类。当你不用添加工作日记的时候你就用你自己的目标类，就不用目标类中添加或者删除方法。 单例模式的常见使用：

**

**1、Windows任务管理器就是很典型的单例模式（这个很熟悉吧），想想看，是不是呢，你能打开两个windows task manager吗？ 2、Windows（回收站）也是典型的单例应用。在整个系统运行过程中，回收站一直维护着仅有的一个实例。 3、网站的计数器，一般也是采用单例模式实现，否则难以同步。 4、数据库连接池的设计一般也是采用单例模式，因为数据库连接是一种数据库资源。数据库软件系统中使用数据库连接池，主要是节省打开或者关闭数据库连接所引起的效率损耗，这种效率上的损耗还是非常昂贵的，因为何用单例模式来维护，就可以大大降低这种损耗。 5、多线程的线程池的设计一般也是采用单例模式，这是由于线程池要方便对池中的线程进行控制。 6、Spring中创建的Bean实例默认都是单例模式存在的。 ****

**

单例模式的饿汉模式：

package com.uplooking.javase.ch08.demo12;


// Singleton模式（单例模式）:饿汉模式
public class DatabaseUtils {

	private static DatabaseUtils instance = new DatabaseUtils();
	
	private DatabaseUtils() {
		
	}
	
	public static DatabaseUtils getInstance() {
		return instance;
	}
	
	public String getConn() {
		return "数据库连接";
	}
}

单例测试2的懒汉模式（其实和饿汉模式有点相同）

package com.uplooking.javase.ch08.demo12;

/*
 * 单例模式（懒汉模式）
 */
public class DatabaseUtils1 {

	private static DatabaseUtils1 instance; // null
	
	private DatabaseUtils1() {
		
	}
	
	public static DatabaseUtils1 getInstance() {
		// 
		if(instance == null) {
			instance = new DatabaseUtils1();
		}
		
		return instance;
	}
}

单元测试代码

package com.uplooking.javase.ch08.demo12;

import org.junit.Test;

public class SingletonTest {
	
	@Test
	public void test2() {
		// DatabaseUtils1 dbUtils1 = new DatabaseUtils1();
		
		DatabaseUtils1 dbUtils1 = DatabaseUtils1.getInstance();
		DatabaseUtils1 dbUtils2 = DatabaseUtils1.getInstance();
		DatabaseUtils1 dbUtils3 = DatabaseUtils1.getInstance();
		
		System.out.println(dbUtils1);
		System.out.println(dbUtils2);
		System.out.println(dbUtils3);
	}

	@Test
	public void test1() {
		/*DatabaseUtils du = new DatabaseUtils();
		
		DatabaseUtils du1 = new DatabaseUtils();
		DatabaseUtils du2 = new DatabaseUtils();*/
		
		DatabaseUtils dbUtils = DatabaseUtils.getInstance();
		
		String conn = dbUtils.getConn();
		
		System.out.println(conn);
		
		DatabaseUtils dbUtils1 = DatabaseUtils.getInstance();
		DatabaseUtils dbUtils2 = DatabaseUtils.getInstance();
		
		// DatabaseUtils@5cb0d902
		System.out.println(dbUtils);
		// DatabaseUtils@5cb0d902
		System.out.println(dbUtils1);
		// DatabaseUtils@5cb0d902
		System.out.println(dbUtils2);
		
	}
}

单例模式就只能new一个，我感觉就像你打开网页的时候就把就里面的所有的类都放在同一个类中，你双击就能快速开启。而不是new T1 类1 类1又是继承父类创造一个。 new T2 类2 又是继承父类 父类先创造一个，会造成内存浪费或者崩溃，因为重复的父类不需要一直new.

第三种 ：模板方法模式

设计模式：也就是写代码的精华，比如设计坦克大战简易版

**

举个生活的例子比如模板方法模式： * 冲咖啡步骤：1、2、3、4 不能颠倒顺序 * 1、取咖啡 * 2、烧开水 * 3、倒开水 * 4、搅拌 就是程序需要严谨的逻辑性和脑力思考，不单单是编写代码 最经典的是MyHttpServlet实例：那么上代码。

**

MyHttpServlet类

package com.uplooking.javase.ch08.demo02;
/**
 * 
 * @Description 处理http请求的类，抽象类，不能直接使用
 * @author Han.FM Email:191878893@qq.com
 * @version 
 * @date 2020年8月17日下午4:10:57
 *
 */
/*
 * 模板方法模式案例
 */
public abstract class MyHttpServlet {

	public void service(String requestName) {
		if(requestName == null) {
			System.out.println("请求错误....");
			return;
		}
		if(requestName.equalsIgnoreCase("Get")) {
			doGet();
		}else if(requestName.equalsIgnoreCase("Post")) {
			doPost();
		}else if(requestName.equalsIgnoreCase("Delete")) {
			doDelete();
		}else if(requestName.equalsIgnoreCase("Put")) {
			doPut();
		}
	}
	
	public abstract void doGet();
	
	public abstract void doPost();
	
	public abstract void doDelete();
	
	public abstract void doPut();

}

UserServlet类

package com.uplooking.javase.ch08.demo02;

public class UserServlet extends MyHttpServlet {

	@Override
	public void doGet() {
		System.out.println("doGet 请求处理....");
	}

	@Override
	public void doPost() {
		System.out.println("doPost 请求处理....");
	}

	@Override
	public void doDelete() {
		System.out.println("doDelete 请求处理...");
	}

	@Override
	public void doPut() {
		System.out.println("doPut 请求处理....");
	}

}

单元测试代码

package com.uplooking.javase.ch08.demo01;

import org.junit.Test;

import com.uplooking.javase.ch08.demo02.MyHttpServlet;
import com.uplooking.javase.ch08.demo02.UserServlet;

public class HttpServletTest {

	@Test
	public void testServlet() {
		MyHttpServlet servlet = new UserServlet();
		
		// servlet.service("get");
		
		// servlet.service("post");
		
		servlet.service("Delete");
		
	}
}