設計模式：
是一套被反覆使用，多數人知曉的，經過分類編目的，代碼設計經驗總結。使用設計模式是爲了可重用代碼，讓代碼更容易讓別人理解，保證代碼的可靠性。毫無疑問，設計模式與給予他人於系統都是多贏的。設計模式使代碼編制真正工程化。設計模式的軟件工程的基石，如同大廈的一塊磚石一樣，項目中合理的運用設計模式可以完美的解決很多問題。每種設計模式中在現在中都有相應的原理來與之對應，每一個模式描述了一個在我們周圍不斷重複發生的問題。以及該問題的核心解決方案。這也是它可以被廣泛應用的原因。
設計模式的分類：
總體來說設計模式氛圍三大類：
創建型模式，共五種：工廠方法模式，抽象工廠模式，單例模式，建造者模式，原型模式。
結構型模式：共七種，適配器模式，裝飾模式，代理模式，外觀模式，橋接模式，組合模式，享元模式。
行爲型模式：
共十一種：策略模式，模板方法模式，觀察者模式，迭代子模式，責任鏈模式，命令模式，備忘錄模式，狀態模式，訪問者模式，中介者模式，解釋器模式。
還有兩種：併發型模式，線程池模式。
設計模式的六大原則：
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){ }}
}
| |
|–|--|
| | |