代理模式and工厂模式之简单插件管理器
问题：咱们老是会遇到这样的问题---在一个复杂系统中，有一些依赖性，关联性低的功能，好比某些场景中须要发送一个邮件。这个时候咱们须要这个“发邮件”的功能，具备低耦合的特性，只须要调用传入参数即可实行这样的功能。可是为了易用性，一般会给这样的--暂且称为插件的东西，加上一个开关。
代理模式：顾名思义，代理，指的是b-a-c，b须要c的功能，可是要通过a再到达c，所以在a上添加一些条件，a就变成了一个开关。举个现实的例子，咱们的家里都有电灯，可是咱们不但愿它一直亮着，想要它亮的时候就亮，灭的时候就灭。在这里咱们的手就是b，开关就是a，电灯就是c。
要点：面向接口编程
beginjavascript
b-a-c这样的过程，归根结底是要实现c的功能，因此第一步咱们须要一个具体实现的过程java
c（发邮件）：编程
1，定义一个发邮件的接口服务器
package plug.inter;
public interface stmp_inter{
public boolean stmp();
}
2，写一个具体发邮件的功能类-stmp_imp.java，实现接口session
package plug.imp;
import plug.inter.stmp_inter;
import plug.plugControl.plugs;
import javax.mail.*;
import javax.mail.internet.*;
import javax.mail.internet.MimeMessage.RecipientType;
import java.util.Properties;
public class stmp_imp implements stmp_inter {
private String from;
private String to;
private String title;
private String val;
private String key;
/*设置发送者邮箱，接受者邮箱，邮件题目，邮件服务器受权码*/
public stmp_imp(String from, String to, String title, String val, String key){
this.from=from;
this.to=to;
this.title=title;
this.val=val;
this.key=key;
stmp();
}
@Override
public boolean stmp() {
Properties properties = new Properties();
/*连接协议*/
properties.put("mail.transport.protocol", "smtp");
/*服务器地址*/
properties.put("mail.smtp.host", "smtp.qq.com");
/*服务器端口*/
properties.put("mail.smtp.port", 465);
/*暂不知道*/
properties.put("mail.smtp.auth", "true");
/*使用ssh连接协议*/
properties.put("mail.smtp.ssl.enable", "true");
/*获得回话对象*/
Session session = Session.getInstance(properties);
Message message = new MimeMessage(session);
try{
message.setFrom(new InternetAddress(from));
message.setRecipients(RecipientType.TO,new InternetAddress[] {
new InternetAddress(to)
});
message.setSubject(title);
message.setText(val);
Transport transport = session.getTransport();
transport.connect(from, key);
transport.sendMessage(message, message.getAllRecipients());
return true;
}
catch(Exception e){
return false;
}
}
@Override
public boolean getState() {
return false;
}
}
3，代理功能类，实现接口dom
package plug.imp;
import plug.inter.stmp_inter;
import plug.plugControl.plugs;
/*
* 代理模式
* 使用时上转型
* */
public class stmp_switch implements stmp_inter{
/*swit为发邮件功能当前状态，是否开启*/
private static boolean swit;
private stmp_imp stm;
private String from;
private String to;
private String title;
private String val;
private String key;
public void stmp_set(String from, String to, String title, String val, String key){
this.from=from;
this.to=to;
this.title=title;
this.val=val;
this.key=key;
}
@Override
public boolean stmp() {
if (stm==null&&swit){
this.stm=new stmp_imp(from,to,title,val,key);
stm.stmp();
return true;
}else{
if(swit){
stm.stmp();
return true;
}else{
return false;
}
}
}
/*设置邮件状态*/
public void stmp(boolean bo){
this.swit=bo;
}
public boolean getState(){
return swit;
}
}
4，调试ssh
package plug.inter;
import plug.imp.stmp_switch;
public class test {
public static void main(String[] arge){
stmp_switch p=new stmp_switch();
System.out.println("发邮件插件当前状态为"+p.getState());
/*开启插件*/
p.stmp(true);
/*设置信息*/
p.stmp_set("510009842@qq.com","1990557780@qq.com","test","test","xxxxxxxxxx");
/*发送邮件*/
p.stmp();
}
}
5，结果ide
6，由此发邮件的插件就作好了，可是这里有两个问题，ui
（1）咱们并不但愿只使用一个插件，可是多个插件放在一块儿就须要一个有效的管理。咱们想要装一台电灯，从接电线到装开关，无疑这是一个专业的事情，这个时候咱们会去专业的电工，电工按照固定的步骤装好电灯。一样的咱们咱们也但愿只提供材料就能直接按开关亮灯。那么就须要引入另外一种模式-工厂模式。this
（2）咱们想要灯亮，只想要找到开关，按下开关就能够了，可是有不少的灯，有的时候你并不知道，那个开关对应的是哪一个灯，这个时候咱们须要给开关贴上标签。
7，定义插件工厂接口
package plug.plugControl;
public interface plugs{
Object draw(String clsz);
}
8，配置插件信息
<?xml version="1.0" encoding="UTF-8"?>
<root>
<!-- 插件名-->
<name>stmp</name>
<!-- 插件开关-->
<claza>plug.imp.stmp_switch</claza>
<!-- 插件实现类-->
<claza_name>stmp</claza_name>
<!-- 做者-->
<admin>巫云</admin>
<!-- 介绍-->
<persent>发邮件</persent>
</root>
9，新建插件信息实体
package plug.plugControl;
/*
* plug信息
*
* */
public class bean_plug {
private String name;
private String claza;
private String claza_name;
private String admin;
private String persent;
private boolean state;
public boolean isState() {
return state;
}
public void setState(boolean state) {
this.state = state;
}
public String getAdmin() {
return admin;
}
public void setAdmin(String admin) {
this.admin = admin;
}
public String getPersent() {
return persent;
}
public void setPersent(String persent) {
this.persent = persent;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getClaza() {
return claza;
}
public void setClaza(String claza) {
this.claza = claza;
}
public String getClaza_name() {
return claza_name;
}
public void setClaza_name(String claza_name) {
this.claza_name = claza_name;
}
}
10，扫描配置文件
package plug.plugControl;
import org.w3c.dom.Document;
import org.w3c.dom.NodeList;
import javax.servlet.http.HttpServletRequest;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import java.io.File;
import java.util.*;
/*
* 扫描全部插件并装载插件信息
* */
public class scans_plug{
private static scans_plug kl=new scans_plug();
public static scans_plug getObj(){
return kl;
}
public Object draw(HttpServletRequest request) {
List plugzz = new LinkedList();
String path=request.getServletContext().getRealPath("WEB-INF/classes/plug/regist");
ArrayList<String> fileName = new ArrayList<String>();
File files = new File(path);
File[] filesList = files.listFiles();
for (File file : filesList) {
try {
DocumentBuilderFactory factory =DocumentBuilderFactory.newInstance();
DocumentBuilder builder=factory.newDocumentBuilder();
Document doc=builder.parse(file);
NodeList name=doc.getElementsByTagName("name");
NodeList claza=doc.getElementsByTagName("claza");
NodeList claza_name=doc.getElementsByTagName("claza_name");
NodeList admin=doc.getElementsByTagName("admin");
NodeList persent=doc.getElementsByTagName("persent");
bean_plug be=new bean_plug();
be.setName(name.item(0).getFirstChild().getNodeValue());
be.setClaza(claza.item(0).getFirstChild().getNodeValue());
be.setClaza_name(claza_name.item(0).getFirstChild().getNodeValue());
be.setAdmin(admin.item(0).getFirstChild().getNodeValue());
be.setPersent(persent.item(0).getFirstChild().getNodeValue());
plugzz.add(be);
} catch (Exception e) {
e.printStackTrace();
}
}
return plugzz;
}
}
11，侦听插件状态
新建状态接口
package plug.plugControl;
public interface state_plug {
boolean getState();
}
使开关继承状态接口
package plug.inter;
import plug.plugControl.plugs;
import plug.plugControl.state_plug;
public interface stmp_inter extends state_plug {
public boolean stmp();
}
11，组建工厂核心
package plug.plugControl;
import plug.imp.stmp_switch;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
/*
* 反射建立plug对象
* */
public class draw_plug implements plugs {
@Override
public Object draw(String clsz) {
try {
Class c=Class.forName(clsz);
Constructor constructor=c.getConstructor();
Object o=constructor.newInstance();
return o;
} catch (ClassNotFoundException e) {
return null;
} catch (NoSuchMethodException e) {
return null;
} catch (InstantiationException e) {
return null;
} catch (IllegalAccessException e) {
return null;
} catch (InvocationTargetException e) {
return null;
}
}
}
12，组建工厂
package plug.plugControl;
import javax.servlet.http.HttpServletRequest;
import java.io.ObjectStreamClass;
import java.util.List;
import java.util.Map;
/**
* 根据扫描的结果组件插件工厂
*/
public class plugFactory {
public Object getPlug(String plug, HttpServletRequest request){
List plugst=(List) scans_plug.getObj().draw(request);
for(Object be:plugst ){
bean_plug bes= (bean_plug) be;
if(plug.equalsIgnoreCase(bes.getClaza_name())){
state_plug c=(state_plug)new draw_plug().draw(bes.getClaza());
bes.setState(c.getState());
return new draw_plug().draw(bes.getClaza());
}
}
return null;
}
}
14，使用
/*
*创建插件工厂
*/
plugFactory plugFactorys=new plugFactory();
/* *//*
选择插件*//*
stmp_switch p=(stmp_switch) plugFactorys.getPlug("STMP",request);
*//*设置插件状态 true/false*//*
p.stmp(true);
*//*设置邮件 （发件人，收件人，题目，内容，邮件受权码）*//*
p.stmp_set("510009842@qq.com","2235733688@qq.com","test","test","smviuilfoqdocbbf");
*//*发送邮件*//*
p.stmp();*/
相关文章
- 1. JAVA模式之简单工厂模式
- 2. 单例模式，工厂模式，代理模式汇总
- 3. 快速理解单例模式，工厂模式，代理模式三大模式
- 4. 工厂模式以及代理模式
- 5. 工厂模式及代理模式
- 6. 代理模式和工厂模式
- 7. java设计模式之单例,工厂,代理模式
- 8. 设计模式粗浅理解之一------简单工厂模式
- 9. 代理模式，简单（静态）工厂模式，单例模式，模板方法模式我的理解
- 10. 工厂模式之简单工厂
- 更多相关文章...
- • Scala 模式匹配 - Scala教程
- • SVN 启动模式 - SVN 教程
- • 委托模式
- • IntelliJ IDEA安装代码格式化插件
相关标签/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
欢迎关注本站公众号,获取更多信息
相关文章
- 1. JAVA模式之简单工厂模式
- 2. 单例模式，工厂模式，代理模式汇总
- 3. 快速理解单例模式，工厂模式，代理模式三大模式
- 4. 工厂模式以及代理模式
- 5. 工厂模式及代理模式
- 6. 代理模式和工厂模式
- 7. java设计模式之单例,工厂,代理模式
- 8. 设计模式粗浅理解之一------简单工厂模式
- 9. 代理模式，简单（静态）工厂模式，单例模式，模板方法模式我的理解
- 10. 工厂模式之简单工厂