设计模式：
是一套被反复使用，多数人知晓的，经过分类编目的，代码设计经验总结。使用设计模式是为了可重用代码，让代码更容易让别人理解，保证代码的可靠性。毫无疑问，设计模式与给予他人于系统都是多赢的。设计模式使代码编制真正工程化。设计模式的软件工程的基石，如同大厦的一块砖石一样，项目中合理的运用设计模式可以完美的解决很多问题。每种设计模式中在现在中都有相应的原理来与之对应，每一个模式描述了一个在我们周围不断重复发生的问题。以及该问题的核心解决方案。这也是它可以被广泛应用的原因。
设计模式的分类：
总体来说设计模式氛围三大类：
创建型模式，共五种：工厂方法模式，抽象工厂模式，单例模式，建造者模式，原型模式。
结构型模式：共七种，适配器模式，装饰模式，代理模式，外观模式，桥接模式，组合模式，享元模式。
行为型模式：
共十一种：策略模式，模板方法模式，观察者模式，迭代子模式，责任链模式，命令模式，备忘录模式，状态模式，访问者模式，中介者模式，解释器模式。
还有两种：并发型模式，线程池模式。
设计模式的六大原则：
1.开闭原则：扩展开放，对修改关闭，在程序需要进行扩展的时候，不能去修改原有的代码，实现一个热插拔的效果。所以一句话概括就是：为了使程序的扩展性更好，易于维护和升级，想要达到这样的效果，我们需要使用接口的和抽象类。
2.里氏代换原则：
任何基类可以出现的地反，子类一定可以出现。LSP是继承复用的基石，只有当衍生也能够在基类的基础上增加新的行为，里氏替换原则的对 开闭原则的补充。实现开闭原则的关键步骤就是抽象化。而基类于子类的继承关系就是抽象化的具体实现，所以里氏替换原则是对实现抽象化的具体的步骤的规范，。
3.依赖倒转原则：
这个是开闭原则的基础，具体内容：针对接口编程，依赖于抽象而不依赖于具体。
4.接口隔离原则：
使用多个隔离接口，比使用单个接口要好，还是一个降低类之间的耦合度的意思。从这儿 我们可以看出设计模式其实就是一个软件的设计思想。从大型软件架构出发，味蕾升级和维护方便，所以上面多次出现降低依赖，降低耦合。
5.迪米特法则：
就是说：一个实体应当尽量少的与其他的实体之间发生相互作用，使得系统功能模块相对独立。
6.合成复用原则：
原则是尽量使用合成聚合的方式，而不是继承。
单例模式：
单例保证一个对象在JVM中只有一个实例，常见的单例 懒汉式，饿汉式。
懒汉式：就是需要的才去实例化，线程不安全。
饿汉式：就是当class文件被加载的时候，初始化天生线程安全。
懒汉式写法：
/**
* 懒汉式单例模式
* 通过私有化构造起的方式实现单例模式 保证JVM中只存在一个
*/
public class Singlteon02 {
private static Singlteon02 singlteon02;//创建一个对象 赋值为空
//私有化构造器
private Singlteon02 (){
}
//通过该方式实例化对象 双重锁保证线程的安全性
public static Singlteon02 getInstance(){
if(singlteon02==null){
synchronized (Singlteon02.class){
if(singlteon02==null){
singlteon02 = new Singlteon02();
}
}
}
return singlteon02;
}
//简单的单例模式线程不安全的
public static Singlteon02 getSinglteon02(){
if(singlteon02==null){
singlteon02 = new Singlteon02();
}
return singlteon02;
}
}
饿汉式写法：
public class Singleton3 {
//在类加载的时候实例化对象 不考虑线程的安全问题
private static Singleton3 singleton3 =new Singleton3();
//私有化构造器
private Singleton3(){
}
//获取对象的实例化
public static Singleton3 getInstance(){
return singleton3;
}
}
工厂模式：
实现创建者和调用者分离；
创建工厂模式：
创建一个接口：
public interface Car {
void run();
}
创建一个工厂：
public class CarFactory {
public static Car createCar(String name){
Car car =null;
switch (name){
case "奥迪":
car = new AutoCar();
break;
case "奔驰":
car = new BenciCar();
break;
default:
break;
}
return car;
}
}
创建奥迪汽车类并实现接口：
public class AutoCar implements Car {
@Override
public void run() {
System.out.println("我是奥迪汽车，速度超快");
}
}
创建奔驰汽车类并实现接口：
public class BenciCar implements Car {
@Override
public void run() {
System.out.println("我是奔驰汽车，造型超帅");
}
}
创建测试类：
public static void test01(){
Car car = CarFactory.createCar("奥迪");
car.run();
}
代理模式概述：
通过代理控制对象的访问，可以详细访问某个对象的方法，在这个方法调用处理，或调用后处理，即aop微型实现，aop核心技术面向切面编程。
代理应用场景：
安全代理可以屏蔽真实角色。
远程代理：远程调用代理类RMI
延迟加载：先加载轻量级代理类，真正需要在加载真实。
代理类分类：
静态代理：静态定义代理类。
动态代理：动态生成代理类。
jdk自带动态代理， Cglib，javaassist字节码操作库。
静态代理：需要自己生成代理类。
静态代理代码实现：
创建一个接口
public interface Host {
void sale();
}
创建接口实现类：
public class ManSaleHost implements Host {
@Override
public void sale() {
System.out.println("我是XXX，我终于可以买房了");
}
}
创建代理对象
public class ProxySale implements Host {
private ManSaleHost manSaleHost;
public ProxySale(ManSaleHost manSaleHost){
this.manSaleHost = manSaleHost;
}
@Override
public void sale() {
System.out.println("我是中介，你买房的任务交给我了。。。");
manSaleHost.sale();
System.out.println("我是中介，，你的房子买好了");
}
}
创建测试类：
public static void test01(){
new ProxySale(new ManSaleHost()).sale();
}
JDK动态创建实现：
创建一个方法并实现InvocationHandler接口
public class JdkProxy implements InvocationHandler {
private Object target;
public JdkProxy(Object target){
this.target =target;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("我是中介，开始监听你买房了");
Object invoke = method.invoke(target, args);
System.out.println("我是中介，结束监听你买房了");
return invoke;
}
}
创建测试类：
public static void test02(){
ManSaleHost manSaleHost = new ManSaleHost();
JdkProxy jdkProxy = new JdkProxy(manSaleHost);
Host o = (Host) Proxy.newProxyInstance(manSaleHost.getClass().getClassLoader(),
manSaleHost.getClass().getInterfaces(), jdkProxy);
o.sale();
}
Cglib动态代理实现：
import net.sf.cglib.proxy.MethodInterceptor;
import java.lang.reflect.Method;
public class Cglibproxyn implements MethodInterceptor {
@Override
public Object intercept(Object o, Method method, Object[] objects, net.sf.cglib.proxy.MethodProxy methodProxy) throws Throwable {
System.out.println("我是中介，开始监听你买房了");
Object invoke = methodProxy.invokeSuper(o, objects);
System.out.println("我是中介，结束监听你买房了");
return invoke;
}
}
创建测试类：
public static void test03(){
Cglibproxyn cglibproxyn = new Cglibproxyn();
Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(ManSaleHost.class);
enhancer.setCallback(cglibproxyn);
ManSaleHost host = (ManSaleHost) enhancer.create();
host.sale();
}
在使用Cgilb创建是别是引入jar对应的包：
Mavne座标
<dependency>
<groupId>cglib</groupId>
<artifactId>cglib</artifactId>
<version>3.2.8</version>
</dependency>
<!-- https://mvnrepository.com/artifact/cglib/cglib-asm -->
<dependency>
<groupId>cglib</groupId>
<artifactId>cglib-asm</artifactId>
<version>1.0</version>
</dependency>
使用线程池支持多个线程的访问
|package com.itmayiedu.day02;
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
-
使用线程池解决http多个请求问题
*/
public class ExecutoTcpServer extends Thread{public static void main(String[] args) throws Exception{
System.out.println("================>>>>>>>TCP服务客户端启动");
ExecutorService executorService = Executors.newCachedThreadPool();//创建可缓存线程池
ServerSocket serverSocket = new ServerSocket(8996);try{ while (true){ Socket accept = serverSocket.accept(); executorService.execute(new Runnable() { @Override public void run() { try{ InputStream inputStream = accept.getInputStream(); byte [] bytes =new byte[1024]; int len = inputStream.read(bytes); String result = new String (bytes,0,len); System.out.println("服务端接受客户端请求："+result); }catch (Exception ex){ } } }); } } catch (Exception ex){ }}
}
| |
|–|--|
| | |