1、构造器模式
对于构造器模式，是如果有一个对象涉及到多个参数需要设置的时候，可以使用构造器模式来构建里面的元素
比如有三个对象：
参考dolpinscheduler中的概念
流程定义
流程实例
任务实例
现在的需求是将三者封装成一个任务从Master传递到Worker，此时就可以使用构造器模式
比如构建一个TaskContext，其中包含了以上对象中的元素
然后使用一个构建一个TaskRequest使用构造器模式来构建对象
public class TaskRequest {
private TaskContext taskContext = new TaskContext();
/**
* 构建TaskRequest
* @return
*/
public static TaskRequest newBuilder() {
return new TaskRequest();
}
/**
* 设置任务相关信息
* @param task
* @return
*/
public TaskRequest setTask(Task task) {
taskContext.setTaskName(task.getTaskName());
taskContext.setTaskType(task.getTaskType());
return this;
}
/**
* 设置流程实例相关信息
* @param processInstance
* @return
*/
public TaskRequest setProcessInstance(ProcessInstance processInstance) {
taskContext.setExecuteUser(processInstance.getExecuteUser());
taskContext.setStartTime(processInstance.getStartTime());
taskContext.setEndTime(processInstance.getEndTime());
return this;
}
/**
* 设置流程定义相关信息
* @param processDefinition
* @return
*/
public TaskRequest setProcessDefinition(ProcessDefinition processDefinition) {
taskContext.setProjectName(processDefinition.getProjectName());
return this;
}
/**
* 获取任务上下文
* @return
*/
public TaskContext build() {
return taskContext;
}
}
2、组合模式 + 访问者模式
对于树形结构的id,pid形式的就可以使用组合模式 + 访问者模式
/**
* 组合模式 + 访问者模式
*/
public class CompositeDemo {
public static void main(String[] args) {
Priority root = new Priority();
root.setName("易观");
Priority dept1 = new Priority();
dept1.setName("大数据平台");
Priority dept2 = new Priority();
dept2.setName("数据平台");
List children = new ArrayList();
children.add(dept1);
children.add(dept2);
root.setChildren(children);
RelatedCheckPriority relatedCheckPriority = new RelatedCheckPriority();
root.execute(relatedCheckPriority);
Boolean relateCheckResult = relatedCheckPriority.getRelateCheckResult();
// 如果都有权限，再删除
if (relateCheckResult){
RemovePriority removePriority = new RemovePriority();
root.execute(removePriority);
}
}
}
class Priority {
private String name;
private List children = new ArrayList();
public void execute(PriorityOperation operation){
operation.doExecute(this);
}
}
interface PriorityOperation {
void doExecute(Priority priority);
}
class RemovePriority implements PriorityOperation{
@Override
public void doExecute(Priority priority) {
List childrenList = priority.getChildren();
if (childrenList != null && childrenList.size() > 0){
for (Priority child : childrenList){
child.execute(this);
}
}
System.out.println("删除 : " + priority.getName());
}
}
class RelatedCheckPriority implements PriorityOperation {
/**
* 关联检查结果
*/
private Boolean relateCheckResult = false;
@Override
public void doExecute(Priority priority) {
List childrenList = priority.getChildren();
if (childrenList != null && childrenList.size() > 0){
for (Priority child : childrenList){
child.execute(this);
}
}
// 这里需要对node进行业务判断，是否有权限
relateCheckResult = true;
}
public Boolean getRelateCheckResult() {
return relateCheckResult;
}
public void setRelateCheckResult(Boolean relateCheckResult) {
this.relateCheckResult = relateCheckResult;
}
} 3、单例
class Singleton {
/**
* 使用volatile避免指令重排
*/
private static volatile Singleton instance = null;
/**
* 构造方法私有化
*/
private Singleton(){}
/**
* 获取实例
* @return
*/
public static Singleton getInstance(){
// 比如说我线程1到这里了，然后线程1，返回的instance就会有问题
if (instance == null){
synchronized (Singleton.class){
if (instance == null){
instance = new Singleton();
/**
* 线程2执行到这里了，由于instance的指令重排
* 导致instance引用不为null，但是里面的成员是null
*/
}
}
}
return instance;
}
}4、状态模式
在复杂状态变换的时候，使用状态模式，状态机，从一个状态到另外一个状态转换
public class Task {
private String taskName;
private String taskType;
private String state;
}
public interface TaskState {
/**
* 状态转换
* @param task
*/
void doTransform(Task task);
/**
* 判断当前状态下是否可以kill
* @param task
* @return
*/
Boolean canKill(Task task);
/**
* 判断当前状态下是否可以删除任务
* @param task
* @return
*/
Boolean canRemove(Task task);
}
public class RunningTaskState implements TaskState {
@Override
public void doTransform(Task task) {
System.out.println(task.getTaskName() + "由提交成功态到正在运行状态");
}
@Override
public Boolean canKill(Task task) {
return false;
}
@Override
public Boolean canRemove(Task task) {
return true;
}
}
public class FinishedTaskState implements TaskState {
@Override
public void doTransform(Task task) {
System.out.println(task.getTaskName() + "由正在运行状态到结束状态");
}
@Override
public Boolean canKill(Task task) {
return true;
}
@Override
public Boolean canRemove(Task task) {
return false;
}
}
public class StateManager {
public static final String SUBMITED = "submited";
public static final String RUNNING = "running";
public static final String FINISHED = "finished";
private RunningTaskState runningTaskState;
private FinishedTaskState finishedTaskState;
public StateManager(RunningTaskState runningTaskState,FinishedTaskState finishedTaskState) {
this.runningTaskState = runningTaskState;
this.finishedTaskState = finishedTaskState;
}
public void runTask(Task task) {
runningTaskState.doTransform(task);
}
public void completeTask(Task task) {
finishedTaskState.doTransform(task);
}
public Boolean canKill(Task task) {
return getTaskState(task).canKill(task);
}
public Boolean canRemove(Task task) {
return getTaskState(task).canRemove(task);
}
private TaskState getTaskState(Task task) {
if (SUBMITED.equals(task.getState())) {
return runningTaskState;
} else if (RUNNING.equals(task.getState())) {
return finishedTaskState;
}
return null;
}
}
public class StateDemo {
public static void main(String[] args) {
StateManager stateManager = new StateManager(
new RunningTaskState(),
new FinishedTaskState()
);
Task task = new Task();
task.setTaskName("测试任务");
task.setTaskType("SHELL");
task.setState(StateManager.SUBMITED);
stateManager.runTask(task);
System.out.println(stateManager.canKill(task));
System.out.println(stateManager.canRemove(task));
}
}
5、策略模式
根据不同的策略选择出来目标的ip
public class StrategyDemo {
public static void main(String[] args) {
Strategy strategy = new Strategy();
RandomSelector randomSelector = new RandomSelector();
RoundRobinSelector roundRobinSelector = new RoundRobinSelector();
String host1 = strategy.select("xx1,xx2", randomSelector);
String host2 = strategy.select("xx1,xx2", roundRobinSelector);
System.out.println(host1);
System.out.println(host2);
}
}
class Strategy {
public String select(String hosts, Selector selector) {
String host = selector.select(hosts);
return host;
}
}
interface Selector {
String select(String hosts);
}
/**
* 随机选择
*/
class RandomSelector implements Selector{
@Override
public String select(String hosts) {
return "127.0.0.1";
}
}
/**
* 轮询选择
*/
class RoundRobinSelector implements Selector {
@Override
public String select(String hosts) {
return "127.0.0.2";
}
}6、模板方法
public class TemplateMethodDemo {
public static void main(String[] args) {
HttpServlet httpServlet = new MyHttpServlet();
httpServlet.doService("get");
}
}
abstract class HttpServlet {
public void doService(String type){
// 公共的业务逻辑
if ("get".equals(type)) {
doGet();
} else if ("post".equals(type)) {
doPost();
}
}
protected void doGet() {}
protected void doPost() {}
}
class MyHttpServlet extends HttpServlet{
@Override
protected void doGet() {
System.out.println("发送get请求");
}
}
7、迭代器模式
public class IteratorDemo {
public static void main(String[] args) {
DBManager dbManager = new DBManagerImpl();
DBIterator iterator = dbManager.iterator();
while (iterator.hasNext()){
List result = iterator.next();
System.out.println(result);
}
}
}
interface DBManager {
DBIterator iterator();
}
class DBManagerImpl implements DBManager {
@Override
public DBIterator iterator() {
return new DBIteratorImpl();
}
}
interface DBIterator {
Boolean hasNext();
List next();
}
class DBIteratorImpl implements DBIterator {
LinkedList list = new LinkedList();
public DBIteratorImpl(){
list.offer("数据1");
list.offer("数据2");
list.offer("数据3");
list.offer("数据4");
}
@Override
public Boolean hasNext() {
return !list.isEmpty();
}
@Override
public List next() {
ArrayList dest = new ArrayList();
dest.add(list.poll());
dest.add(list.poll());
return dest;
}
} 8、备忘录模式
这个针对的是DS的TaskPriorityQueueImpl 和 TaskPriorityQueueConsumer
public void put(StockUpdateMessage message) throws Exception {
/**
* 每次要往内存队列放消息之前，先检查一下离线存储标识
* 如果触发了离线存储，直接就往离线存储中写入，不要走后面的逻辑了
* 写完离线存储之后，需要检查一下内存队列的大小，如果内存队列已经清零，则启动一个后台线程
* 让后台线程去将离线存储中的数据恢复写入内存队列中
*/
if (offlineStorageManager.getOffline()){
//往DB中放数据
offlineStorageManager.store(message);
if (queue.size() == 0){
new OfflineResumeThread(offlineStorageManager,this).start();
}
return;
}
// 如果内存队列已经满了，此时就触发离线存储
if (QUEUE_MAX_SIZE.equals(queue.size())){
offlineStorageManager.store(message);
offlineStorageManager.setOffline(true);
return;
}
queue.put(message);
}
OfflineResumeThread 线程：
public void run() {
try {
OfflineStorageIterator iterator = offlineStorageManager.iteartor();
// 如果表中还有数据的话
while (iterator.hasNext()){
try {
// 每次就从mysql中查询50条数据，批量查询，批量处理，批量删除
List stockUpdateMessages = iterator.next();
// 将这批数据写入内存队列中
for (StockUpdateMessage message : stockUpdateMessages){
stockUpdateQueue.putDirect(message);
}
// 批量删除这批数据
offlineStorageManager.removeByBatch(stockUpdateMessages);
}catch (Exception e){
logger.error("error",e);
}
}
// 此时mysql中的数据全部恢复，更新内存标识
offlineStorageManager.setOffline(false);
}catch (Exception e){
logger.error("error",e);
}
} 9、责任链模式
public class ChainPatternDemo {
public static void main(String[] args) {
HandlerFactory factory = new HandlerFactory();
Handler handlerChain = factory.getHandlerChain();
handlerChain.execute();
}
}
class HandlerFactory {
Handler firstHandler;
public Handler getHandlerChain(){
buildHandlerChain();
return firstHandler;
}
private void buildHandlerChain(){
Handler thirdHandler = new ProcessResult(null);
Handler secondHandler = new ExecuteTask(thirdHandler);
firstHandler = new ResolveParamter(secondHandler);
}
}
abstract class Handler {
protected Handler successor;
public Handler(Handler successor){
this.successor = successor;
}
abstract void execute();
}
class ResolveParamter extends Handler {
public ResolveParamter(Handler successor) {
super(successor);
}
@Override
void execute() {
System.out.println("解析参数");
if (successor != null){
successor.execute();
}
}
}
class ExecuteTask extends Handler {
public ExecuteTask(Handler successor) {
super(successor);
}
@Override
void execute() {
System.out.println("执行任务");
if (successor != null){
successor.execute();
}
}
}
class ProcessResult extends Handler {
public ProcessResult(Handler successor) {
super(successor);
}
@Override
void execute() {
System.out.println("处理结果");
if (successor != null){
successor.execute();
}
}
}10、门面模式
Service就是经典的门面模式，融合了很多dao
public class FacadePatternDemo {
public static void main(String[] args) {
/**
* 假设是子系统2
*/
SystemFacade facade = new SystemFacade();
facade.execute();
/**
* 好处1：子系统2不需要care太多的模块，只要care一个门面类的接口就可以了
* 好处2：如果多个地方都要调用这段逻辑，那么如果这个逻辑变了，只需要在门面类一个地方修改就可以了
*/
}
/**
* 子系统1的门面类
*/
public static class SystemFacade {
public void execute(){
/**
* 子系统，封装了自己的多个模块，ABC，基于自己多个模块的功能，对外统一暴露出去一个功能
*/
ModuleA moduleA = new ModuleA();
ModuleB moduleB = new ModuleB();
ModuleC moduleC = new ModuleC();
moduleA.execute();
moduleB.execute();
moduleC.execute();
System.out.println("新增的一段逻辑");
}
}
public static class ModuleA {
public void execute() {
System.out.println("子系统1的模块A的功能");
}
}
public static class ModuleB {
public void execute() {
System.out.println("子系统1的模块B的功能");
}
}
public static class ModuleC {
public void execute() {
System.out.println("子系统1的模块C的功能");
}
}
}11、装饰模式
对方法的增强
public class DecoratorPatternDemo {
public static void main(String[] args) {
ConcreteComponent concreteComponent = new ConcreteComponent();
Decorator decorator = new Decorator(concreteComponent);
decorator.execute();
}
}
interface Component {
void execute();
}
class ConcreteComponent implements Component {
@Override
public void execute() {
System.out.println("执行基础功能");
}
}
class Decorator implements Component {
private Component component;
public Decorator(Component component){
this.component = component;
}
@Override
public void execute() {
System.out.println("在执行基础功能之前，执行部分功能增强");
component.execute();
System.out.println("在执行基础功能之后，执行部分功能增强");
}
}12、适配器
public class AdapterPatterDemo {
public static void main(String[] args) {
NewInterface oldObject = new NewInterfaceAdapter(new OldInterfaceImpl());
oldObject.newExecute();
NewInterface newOjbect = new NewInterfaceImpl();
newOjbect.newExecute();
/**
* 适配器
* 就是你手上有新老两个接口和一个老接口的实现类
* 但是现在系统中药面向新接口来开发，老接口的实现类就不能直接用了，不能直接面向老接口来开发
* 开发一个老接口到新接口的一个适配器
* 适配器是实现了新接口的，但是适配器中持有老接口实现类实例的引用
* 适配器的新接口方法的实现，全部基于老接口实现类的老方法来实现即可
* 对于调用方而言，只要使用适配器开发即可，就可以通过面向新接口开发，底层使用老接口实现类
*/
}
/**
* 定义一个适配器
*/
public static class NewInterfaceAdapter implements NewInterface{
private OldInterface oldObject;
public NewInterfaceAdapter(OldInterface oldObject){
this.oldObject = oldObject;
}
@Override
public void newExecute() {
oldObject.oldExecute();
}
}
/**
* 老版本接口
*/
public static interface OldInterface{
void oldExecute();
}
public static class OldInterfaceImpl implements OldInterface{
@Override
public void oldExecute() {
System.out.println("老版本接口实现的功能逻辑");
}
}
/**
* 新版版接口
*/
public static interface NewInterface{
void newExecute();
}
public static class NewInterfaceImpl implements NewInterface{
@Override
public void newExecute() {
System.out.println("新版本接口实现的功能逻辑");
}
}
}
Java IO
String SEPARATOR = File.separator;
File file = new File("e:" + SEPARATOR + "io" + SEPARATOR + "test.txt");
//BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(new FileInputStream(file)));
// 备注上面这个初始化过程就是多次使用包装来完成的,不推荐这么写,会让新手看不懂。
//1、获得子节输入流
FileInputStream fileInputStream=new FileInputStream(file);
//2、构造转换流(是继承Reader的)
InputStreamReader inputStreamReader=new InputStreamReader(fileInputStream);
//3、 构造缓冲字符流
BufferedReader bufferedReader=new BufferedReader(inputStreamReader);
/**
* 备注1、2两步骤体现出了适配器模式
* 由于InputStream是字节流不能享受到字符流读取字符那么便捷的功能，因此借助
* InputStreamReader将其转为Reader子类，因此可以拥有便捷操作文本文件方法。
*/
/**
* 2、3两步骤体现了装饰模式(wrapper包装模式)
* 将InputStream字节流包装为BufferedReader过程就装饰的过程。一开始
* InputStream只有read一个字节的方法，包装为Reader之后拥有read一个字符的功
* 能，在包装成BufferedReader之后就拥有read一行字符串功能
*/13、原型模式
public T clone(Class clazz) throws Exception{
T target = clazz.newInstance();
BeanCopierUtils.copyProperties(this,target);
return target;
} BeanCopierUtils 是cglib的一个工具对于类之间的clone
14、享元模式
比如说Worker将返回值返回给Master之后，Master使用Map进行保存，然后对于Master基于任务的状态的判断，走的是这个Map，如果缓存中有则走缓存，没有则走数据库
15、代理模式
JDK
public class JDKProxyDemo {
public static void main(String[] args) throws Exception {
JDKProxy proxy = new JDKProxy();
IUserManager userManager = (IUserManager)proxy.bind(new UserManagerImpl());
userManager.addUser("zhagnsan","123");
}
}
interface IUserManager {
void addUser(String id, String password);
}
class UserManagerImpl implements IUserManager {
@Override
public void addUser(String id, String password) {
System.out.println("======调用了UserManagerImpl.addUser()方法======");
}
}
class JDKProxy implements InvocationHandler {
private Object target;
public Object bind(Object target){
this.target = target;
return Proxy.newProxyInstance(this.target.getClass().getClassLoader(),
this.target.getClass().getInterfaces(),
this);
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
Object result = method.invoke(this.target,args);
return result;
}
}
CGLIB
/**
* CGLibProxy动态代理类
*/
public class CGLibProxy implements MethodInterceptor {
/** CGLib需要代理的目标对象 */
private Object targetObject;
public Object createProxyObject(Object obj) {
this.targetObject = obj;
Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(obj.getClass());
enhancer.setCallback(this);
Object proxyObj = enhancer.create();
// 返回代理对象
return proxyObj;
}
@Override
public Object intercept(Object proxy, Method method, Object[] args,
MethodProxy methodProxy) throws Throwable {
Object obj = method.invoke(targetObject, args);
return obj;
}
}Dubbo客户端动态代理
public class NettyClient {
private static ExecutorService executorService = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());
private static NettyClientHandler clientHandler;
//TODO 在这里实现了动态代理模式
public Object getBean(final Class> serviceClass,final String provideName) {
return Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(),
new Class>[]{serviceClass},(proxy, method, args) -> {
if (clientHandler == null) {
//TODO 在这里初始化netty客户度，初始化的时候已经和server建立的连接，有了上下文
initClient();
}
//TODO 初始化完毕之后给客户度设置参数，HelloService#hello#你好
clientHandler.setParam(provideName + args[0]);
//TODO 通过线程池对任务进行提交，因为NettyClientHandler实现了Callable接口，所以可以直接进行任务的提交
return executorService.submit(clientHandler).get();
});
}
private static void initClient() {
clientHandler = new NettyClientHandler();
EventLoopGroup group = new NioEventLoopGroup();
Bootstrap bootstrap = new Bootstrap();
bootstrap.group(group)
.channel(NioSocketChannel.class)
.option(ChannelOption.TCP_NODELAY,true)
.handler(new ChannelInitializer() {
@Override
protected void initChannel(SocketChannel ch) throws Exception {
ChannelPipeline pipeline = ch.pipeline();
pipeline.addLast(new StringDecoder());
pipeline.addLast(new StringEncoder());
pipeline.addLast(clientHandler);
}
});
try {
bootstrap.connect("127.0.0.1",7777).sync();
} catch (Exception e) {
e.printStackTrace();
}
}
}
public class NettyClientHandler extends ChannelInboundHandlerAdapter implements Callable {
private ChannelHandlerContext context;
private String result;
private String param;
@Override
public void channelActive(ChannelHandlerContext ctx) throws Exception {
context = ctx;
}
@Override
public synchronized void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
//TODO 在这里等待结果返回
result = msg.toString();
notify();
}
@Override
public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
}
@Override
public synchronized Object call() throws Exception {
//TODO 这里将数据写了出去
context.writeAndFlush(param);
wait();
return result;
}
void setParam(String param) {
this.param = param;
}
}
动态代理
public class Demo {
public static void main(String[] args) throws Exception {
JdkHandler jdkHandler = new JdkHandler();
User bookApi = (User)jdkHandler.bind(User.class);
bookApi.say("qiaozhanwei");
bookApi.say("qiaozhanwei",30);
}
}
interface User {
void say(String name);
void say(String name,int age);
}
class JdkHandler implements InvocationHandler {
public Object bind(Class> serviceClass) {
return Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(),
new Class>[]{serviceClass},this);
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
for (Object object : args) {
System.out.println(object);
}
System.out.println(method.getName());
return null;
}
} 总结
1）JDK动态代理只能对实现了接口的类生成代理，而不能针对类
2）CGLIB是针对类实现代理，主要是对指定的类生成一个子类，覆盖其中的方法，并覆盖其中方法实现增强，但是因为采用的是继承，所以该类或方法最好不要声明成final
服务器托管，北京服务器托管，服务器租用 http://www.fwqtg.net
