import java.io.File;
import java.util.Date;
import java.util.List;

import javax.mail.BodyPart;

public interface IMail {
public void set主题(String 主题);
public void setText(String Text);
public void setCotnent(BodyPart content);
public void set发件人(Email地址 发件人);
public void set收件人(List<Email地址> 收件人);
public void set抄送人(List<Email地址> 抄送人);
public void set暗送人(List<Email地址> 暗送人);
public void set邮件时间(Date time);
public void set附件(List<File> files);
public Email地址 get发件人();
public List<Email地址> get收件人();
public List<Email地址> get抄送人();
public List<Email地址> get暗送人();
public List<File> get附件();
public Date get邮件时间();
public String get主题();
public String getText();
public BodyPart getContent();
}

<2>Mail类
import java.io.File;
import java.util.Date;
import java.util.List;

import javax.mail.BodyPart;

public class Mail implements IMail{
private Email地址 发件人;
private String 主题;
private String text;
private BodyPart content;
private List<Email地址> 抄送人;
private List<Email地址> 收件人;
private List<Email地址> 暗送人;
private Date 邮件时间 ;
private List<File> 附件;

public Email地址 get发件人() {
    return this.发件人;
}

public List<Email地址> get抄送人() {
    return this.抄送人;
}

public List<Email地址> get收件人() {
    return this.收件人;
}

public List<Email地址> get暗送人() {
    return this.暗送人;
}

public Date get邮件时间() {
    return this.邮件时间;
}

public List<File> get附件() {
    return this.附件;
}

public void set发件人(Email地址 发件人) {
    this.发件人 = 发件人;
}

public void set抄送人(List<Email地址> 抄送人) {
    this.抄送人 = 抄送人;
}

public void set收件人(List<Email地址> 收件人) {
    this.收件人 = 收件人;
}

public void set暗送人(List<Email地址> 暗送人) {
    this.暗送人 = 暗送人;
}

public void set邮件时间(Date time) {
    this.邮件时间 = time;
}

public void set附件(List<File> files) {
    this.附件 = files;
}

public BodyPart getContent() {
    return this.content;
}

public String getText() {
    return this.text;
}

public String get主题() {
    return this.主题;
}

public void setCotnent(BodyPart content) {
    this.content = content;
}

public void setText(String text) {
    this.text = text;
}

public void set主题(String 主题) {
    this.主题 = 主题;
}
}

<3>Abstract邮件发送服务器
import java.io.File;
import java.util.Date;
import java.util.List;

import javax.activation.DataHandler;
import javax.activation.DataSource;
import javax.activation.FileDataSource;
import javax.mail.BodyPart;
import javax.mail.Message;
import javax.mail.Multipart;
import javax.mail.Session;
import javax.mail.internet.InternetAddress;
import javax.mail.internet.MimeBodyPart;
import javax.mail.internet.MimeMessage;
import javax.mail.internet.MimeMultipart;
import javax.mail.internet.MimeUtility;

public abstract class Abstract邮件发送服务器 {
protected IMail 邮件;
protected Session session;
protected String send方式;

public Abstract邮件发送服务器() {
  
}

protected InternetAddress[] getAddressByType(List<Email地址> list) throws Exception {
    if (list != null) {
     InternetAddress address[] = new InternetAddress[list.size()];
     for (int i = 0 ; i < list.size(); i++) {
      address[i] = list.get(i).toInternetAddress();
     }
     return address;
    }
    return null;
}
public void 发送邮件() {
    try {
     MimeMessage message = new MimeMessage(session);
     Multipart multipart = new MimeMultipart();
     message.setSubject(邮件.get主题(),"utf-8");
     if(邮件.getText() != null)
      message.setText(邮件.getText(),"utf-8");
     message.setSentDate(邮件.get邮件时间()==null?new Date():this.邮件.get邮件时间());
     multipart.addBodyPart(this.邮件.getContent());

     //添加发件人
     message.setFrom(邮件.get发件人().toInternetAddress());
   
     //添加收件人
     InternetAddress address[] = this.getAddressByType(this.邮件.get收件人());
     if (address != null)
      message.addRecipients(Message.RecipientType.TO,address);
     //添加抄送人
     address = this.getAddressByType(this.邮件.get抄送人());
     if (address != null)
      message.addRecipients(Message.RecipientType.CC,address);
     //添加暗送人
     address = this.getAddressByType(this.邮件.get暗送人());
     if (address != null)
      message.addRecipients(Message.RecipientType.BCC,address);
     //添加附件
     if (this.邮件.get附件() != null) {
      for (int i = 0; i < this.邮件.get附件().size(); i++) {
       File file = this.邮件.get附件().get(i);
       BodyPart messageBodyPart = new MimeBodyPart();  
       DataSource source = new FileDataSource(file);
       messageBodyPart.setDataHandler(new DataHandler(source));
       messageBodyPart.setFileName(MimeUtility.encodeWord(file.getName(),"UTF-8","Q"));
       multipart.addBodyPart(messageBodyPart);     
      }
     }
     message.setContent(multipart);
     if(send方式 == null)
      send方式 = "smtp";
     session.getTransport(send方式).send(message);
    } catch (Exception e) {
     e.printStackTrace();
    }
}

public Session    getSession() {
    return session;
}
public void setSession(Session session) {
    this.session = session;
}
public IMail get邮件() {
    return 邮件;
}
public void set邮件(IMail 邮件) {
    this.邮件 = 邮件;
}

}

<4>Abstract发送邮件建造者
import javax.mail.Session;

public abstract class Abstract发送邮件建造者 {
protected Abstract邮件发送服务器 mailServer;

public Abstract发送邮件建造者() {
  
}

public abstract void 建造邮件(IMail mail);

public abstract void 建造邮件session(Session session);

public void 建造发送邮件() {
    this.mailServer.发送邮件();
}
}

<5>Smtp邮件发送服务器
public class Smtp邮件发送服务器 extends Abstract邮件发送服务器 {
public Smtp邮件发送服务器() {
    this.send方式 = "smtp";
}
}

<6>Smtp发送邮件建造者
import java.util.Properties;

import javax.mail.Session;

public class Smtp发送邮件建造者 extends Abstract发送邮件建造者 {
public Smtp发送邮件建造者() {
    this.mailServer = new Smtp邮件发送服务器();
}

@Override
public void 建造邮件(IMail mail) {
    this.mailServer.set邮件(mail);  
}

@Override
public void 建造邮件session(Session session) {
    this.mailServer.setSession(session);  
}
}

<7>PasswordAuthenticator
import javax.mail.Authenticator;
import javax.mail.PasswordAuthentication;

class PasswordAuthenticator extends Authenticator {

      private String username;
      private String password;

      public PasswordAuthenticator(String username, String password) {
          this.username = username;
          this.password = password;
      }

      protected PasswordAuthentication getPasswordAuthentication() {
          return new PasswordAuthentication(username, password);
      }

}

<8>Email地址
import javax.mail.internet.InternetAddress;
import javax.mail.internet.MimeUtility;

public class Email地址 {
protected String 地址;

protected String 地址显示别名;

public Email地址() {
  
}

public Email地址(String 地址, String 地址显示别名){
    this.地址 = 地址;
    this.地址显示别名 = 地址显示别名;
}

public String get地址() {
    return 地址;
}

public void set地址(String 地址) {
    this.地址 = 地址;
}

public String get地址显示别名() {
    return 地址显示别名;
}

public void set地址显示别名(String 地址显示别名) {
    this.地址显示别名 = 地址显示别名;
}

public InternetAddress toInternetAddress() throws Exception {
    if (地址显示别名 != null && !地址显示别名.trim().equals("")) {
     return new InternetAddress(地址, MimeUtility.encodeWord(地址显示别名,
       "utf-8", "Q"));
    }
    return new InternetAddress(地址);
}
}

<9>发送邮件Director
import javax.mail.Session;

public class 发送邮件Director {
Abstract发送邮件建造者 build;

public 发送邮件Director(Abstract发送邮件建造者 build) {
    this.build = build;
}

public void 发送邮件建造(IMail mail, Session session) {
    this.build.建造邮件(mail);
    this.build.建造邮件session(session);
    this.build.建造发送邮件();
}
}

<10>Client
import java.io.File;
import java.util.ArrayList;
import java.util.List;
import java.util.Properties;

import javax.mail.BodyPart;
import javax.mail.Session;
import javax.mail.internet.MimeBodyPart;

public class Client {
public static void main(String args[]) throws Exception {
    IMail mail = new Mail();
    mail.set主题("제외되는");
    mail.set发件人(new Email地址("james_zhao_abm@163.com","赵成明"));
    List<Email地址> list = new ArrayList<Email地址>();
    list.add(new Email地址("jszhaochengming@hotmail.com","刘德华"));
    mail.set收件人(list);
    list    = new ArrayList<Email地址>();
    list.add(new Email地址("james_zhao_abm@163.com","纯净水"));
    list.add(new Email地址("jszhaochengming@hotmail.com","刘德华"));
    mail.set抄送人(list);
    BodyPart contentPart = new MimeBodyPart();
    contentPart.setHeader("Content-Transfer-Encoding",     "base64");   
    contentPart.setContent("测试哟见呵呵","text/html;charset=utf-8");
    mail.setCotnent(contentPart);
    List<File> listF = new ArrayList<File>();
    listF.add(new File("d:/출주제외되는2.rar"));
    mail.set附件(listF);
    Smtp发送邮件建造者 smtp = new Smtp发送邮件建造者();
    Properties 属性配置    = new Properties();
    属性配置.put("mail.smtp.host", "smtp.163.com");
    属性配置.put("mail.smtp.auth", "true");
    Session session = Session.getInstance(属性配置,new PasswordAuthenticator("xxxxx", "xxxxx"));
    发送邮件Director director = new 发送邮件Director(smtp);
    director.发送邮件建造(mail, session);
}
}

简单工厂模式是由一个工厂对象来决定创建出哪一种产品类的对象。

简单工厂模式就是由一个工厂类根据传入的参数决定创建出哪一种产品类的对象。

/*******************************************/

package 工厂.简单工厂模式;

public interface 汽车 {

public void 开车();

public void 停车();

public void 年检();

public void 鸣笛();

//...等等

}

/*******************************************/

package 工厂.简单工厂模式;

public class 宝马汽车 implements 汽车 {

public static final String ;

public static final String BRAND = "宝马汽车";

public void 开车() {

    System.out.println(BRAND+".开车");

}

public void 停车() {

    System.out.println(BRAND+".停车");

}

public void 年检() {

    System.out.println(BRAND+".年检");

}

public void 鸣笛() {

    System.out.println(BRAND+".鸣笛");

}

}

/*******************************************/

package 工厂.简单工厂模式;

public class 奔驰汽车 implements 汽车 {

public static final String ;

public static final String BRAND = "奔驰汽车";

public void 开车() {

    System.out.println(BRAND+".开车");

}

public void 停车() {

    System.out.println(BRAND+".停车");

}

public void 年检() {

    System.out.println(BRAND+".年检");

}

public void 鸣笛() {

    System.out.println(BRAND+".鸣笛");

}

}

/*******************************************/

package 工厂.简单工厂模式;

public class 汽车销售工厂 {

public static 汽车 试车(String ID) throws Exception {

    if (ID.equals(宝马汽车.ID)) {

     return new 宝马汽车();

    } else if (ID.equals(奔驰汽车.ID)) {

     return new 奔驰汽车();

    }

    throw new Exception("没有这个品牌的汽车!");

}

}

/*******************************************/

package 工厂.简单工厂模式;

public class 消费者 {

public void 试试汽车(String ID) {

    try {

     汽车 car = 汽车销售工厂.试车(ID);

     car.开车();

     car.停车();

     car.鸣笛();

    } catch (Exception e) {

     System.out.println("连宝马都没有,换个销售公司!");

     e.printStackTrace();

    }

}

public static void main(String args[]) {

    消费者 王二 = new 消费者();

    王二.试试汽车(宝马汽车.ID);

    王二.试试汽车(奔驰汽车.ID);

}

}

我们使用的界面上有

文本 {Linux文本,Windows文本}

标签 {Linux标签,Windows标签}

等等.

第一部分 抽象工厂的实现

interface 文本 {}

interface 标签 {}

class Linux文本 implements 文本{

     public String toString() {

         return "Linux文本";

     }

}

class Linux标签 implements 标签{

     public String toString() {

         return "Linux标签";

     }

}

class Windows文本 implements 文本{

     public String toString() {

         return "Windows文本";

     }

}

class Windows标签 implements 标签{

     public String toString() {

         return "Windows标签";

     }

}

interface 组件工厂 {

     public 文本 生产文本组件();

     public 标签 生产标签组件();

}

class Linux组件工厂 implements 组件工厂 {    

     public 文本 生产文本组件() {

         return new Linux文本();

     }

     public 标签 生产标签组件() {

         return new Linux标签();

     }

}

class Windows标签组件工厂 implements 组件工厂 {    

     public 文本 生产文本组件() {

         return new Windows文本();

     }

     public 标签 生产标签组件() {

         return new Windows标签();

     }

}

class 客户系统显示 {

     private 文本 text;

     private 标签 label;

     public static void main(String args[]) {

         客户系统显示 clientOS = new 客户系统显示();

         组件工厂 factory = new Linux组件工厂();

         clientOS.label = factory.生产标签组件();

         clientOS.text = factory.生产文本组件();    

         System.out.println(clientOS.label);

         System.out.println(clientOS.text);

     }

}

如果按照上面的标准，我们要添加一个新的组件 下拉框

A.需要修改的地方有

1.组件工厂

2.Linux组件工厂

3.Windows标签组件工厂

B.需要增加的有

1.interface 下拉框 {}

2.class Linux下拉框 implements 下拉框

3.class Windows下拉框 implements 下拉框

C.调用的地方也会多出一个factory.生产下拉框组件();    

第二部分 改革抽象工厂

有没有觉得要改动的地方有点多呢,下面我们来改革一下

1.把 组件工厂中的

生产文本组件();

生产标签组件();

...

都改为

生产组件(组件标识);

这样带来的好处就是前面提到的，以下的修改就免去了

/**************************/

......

A.需要修改的地方有

1.组件工厂

2.Linux组件工厂

3.Windows标签组件工厂

......

/**************************/

要做到上面的，需要做以下几件事情

1.增加一个Annotation来说明后面增加的 组件注册表

@interface 组件描述 {

     Class 组件类();

}

2.增加一个Enum

enum 组件注册表 {

     /**

      * Linux_文本 的对应实体类为 Linux文本

      */

     @组件描述(组件类 = Linux文本.class)

     Linux_文本,

     @组件描述(组件类 = Linux标签.class)

     Linux_标签,

     @组件描述(组件类 = Windows文本.class)

     Windows_文本,

     @组件描述(组件类 = Windows标签.class)

     Windows_标签,

}

3.我们不再需要

interface 组件工厂，class Windows标签组件工厂，class Linux组件工厂

我们把 接口 组件工厂改为实体类

为了保持可以扩展和维护

我们定义了一个 接口 工厂

interface 工厂 {

}

class 组件工厂 implements 工厂 {

     public 组件 生产组件(组件注册表 ID) throws Exception {

         try {

             Field f = 组件注册表.class.getField(ID.toString());

             组件描述 描述 = f.getAnnotation(组件描述.class);

             Class 组件类 = 描述.组件类();

             return (组件) 组件类.newInstance();

             // 注意,组件类.newInstance();的调用的时候要确保这个组件类有个不带参数的构造函数

             // 如果要使用带参数的构造函数,可以在@interface 组件描述 中增加一个成员

             // 构造函数[] 构造函数参数() default{};

             // @interface 构造函数 {Class[] 构造函数的参数();}

             // 通过 组件类.getConstructors(); 来得到这个类的不同构造方法

             // 这样就可以根据用户提供的信息用不同的构造函数实例话对象

             // 带不同的构造函数,这里先不讨论，后面我会给出代码

         } catch (Exception e) {

             throw new Exception ("没有找到对应的组件");

         }

     }

}

经过上面的修改,代码如下

import java.lang.annotation.Retention;

import java.lang.annotation.RetentionPolicy;

import java.lang.reflect.Field;

@Retention(RetentionPolicy.RUNTIME)

@interface 组件描述 {

     Class 组件类();

}

enum 组件注册表 {

     @组件描述(组件类 = Linux文本.class)

     Linux_文本,

     @组件描述(组件类 = Linux标签.class)

     Linux_标签,

     @组件描述(组件类 = Windows文本.class)

     Windows_文本,

     @组件描述(组件类 = Windows标签.class)

     Windows_标签,

}

interface 组件 {}

interface 文本 extends 组件 {}

interface 标签 extends 组件 {}

class Linux文本 implements 文本{

     public String toString() {

         return "Linux文本";

     }

}

class Linux标签 implements 标签{

     public String toString() {

         return "Linux标签";

     }

}

class Windows文本 implements 文本{

     public String toString() {

         return "Windows文本";

     }

}

class Windows标签 implements 标签{

     public String toString() {

         return "Windows标签";

     }

}

interface 工厂 {}

class 组件工厂 implements 工厂{

     public 组件 生产组件(组件注册表 ID) throws Exception {

         try {

             Field f = 组件注册表.class.getField(ID.toString());

             组件描述 描述 = f.getAnnotation(组件描述.class);

             Class 组件类 = 描述.组件类();

             return (组件) 组件类.newInstance();

         } catch (Exception e) {

             throw new Exception ("没有找到对应的组件");

         }

     }

}

class 客户系统显示 {

     private 文本 text;

     private 标签 label;

     public static void main(String args[]) {

         客户系统显示 clientOS = new 客户系统显示();

         组件工厂 factory = new 组件工厂();

         try {

             clientOS.text = (文本) factory.生产组件(组件注册表.Linux_文本);

             clientOS.label = (标签) factory.生产组件(组件注册表.Linux_标签);

         } catch (Exception e) {

             e.printStackTrace();

         }

         System.out.println(clientOS.label);

         System.out.println(clientOS.text);

     }

}

这个时候我们增加一个 下拉框

需要改动的地方

1.增加一个 interface 下拉框 extends 组件 {}

2.增加2个实现类

class Windows下拉框 implements 下拉框{}

class Linux下拉框implements 下拉框{}

3.组件注册表 增加2个成员

@组件描述(组件类 = Linux下拉框.class)

Linux_下拉框,    

@组件描述(组件类 = Windows下拉框.class)

Windows_下拉框,

和上面的比起来我们只需要在 组件注册表中增加2个成员，而不需要去修改

1.组件工厂

2.Linux组件工厂

3.Windows标签组件工厂

因为这里要修改3个地方，是不是觉得麻烦,反正我觉得麻烦了点

还有一点就是用户调用的时候不需要再使用factory.生产标签组件();等方法，只要一个factory.生产组件就可以了,这样符合简单工厂的模式

第三部分 带参数的构造函数代码

import java.lang.annotation.Annotation;

import java.lang.annotation.Retention;

import java.lang.annotation.RetentionPolicy;

import java.lang.reflect.Constructor;

import java.lang.reflect.Field;

import java.util.ArrayList;

import java.util.List;

@Retention(RetentionPolicy.RUNTIME)

@interface 构造函数 {

     /**

      * 构造函数的参数类型

      * @return

      */

     Class[] 构造函数的参数();

}

@Retention(RetentionPolicy.RUNTIME)

@interface 组件描述 {

     Class 组件类();

     /**

      * 返回组件的构造函数 <br>

      * 如果长度为0,则调用没有参数的构造函数 <br>

      * @return 构造函数[]

      */

     构造函数[] 构造函数参数() default{};

}

enum 组件注册表 {

     /**

      * Linux_文本 的对应实体类为 Linux文本 <br>

      * Linux的构造函数有 <br>

      * 1. Linux文本(String 显示的文字) ; <br>

      * 2. Linux文本(String 显示的文字, Integer 文本字体大小);

      */

     @组件描述(组件类 = Linux文本.class,

             构造函数参数 = {@构造函数(构造函数的参数={String.class}) ,

         @构造函数(构造函数的参数={String.class, Integer.class}) } )

     Linux_文本,

     @组件描述(组件类 = Linux标签.class)

     Linux_标签,

     @组件描述(组件类 = Windows文本.class)

     Windows_文本,

     @组件描述(组件类 = Windows标签.class)

     Windows_标签,

}

interface 组件 {}

interface 文本 extends 组件 {}

interface 标签 extends 组件 {}

class Linux文本 implements 文本{

     private String text;

     private Integer size;

     public Linux文本(String text) {

         this.text = text;

     }

     public Linux文本(String text, Integer size) {

         this.text = text;

         this.size = size;

     }

     public String toString() {

         return "Linux文本" + (text == null ? "":",文本内容为:"+text) + (size == null ? "":",文本字体大小为:"+size);

     }

}

class Linux标签 implements 标签{

     public String toString() {

         return "Linux标签";

     }

}

class Windows文本 implements 文本{

     public String toString() {

         return "Windows文本";

     }

}

class Windows标签 implements 标签{

     public String toString() {

         return "Windows标签";

     }

}

interface 工厂 {}

class 组件工厂 implements 工厂{

     public 组件 生产组件(组件注册表 ID, Object[] 参数) throws Exception {

         try {

             Field f = 组件注册表.class.getField(ID.toString());

             组件描述 描述 = f.getAnnotation(组件描述.class);

             Class 组件类 = 描述.组件类();

             构造函数[] ano = 描述.构造函数参数();

             if (参数 != null) {

                 for (int i = 0; i < ano.length; i++) {

                     构造函数 temp = ano;

                     Class[] 构造函数S = temp.构造函数的参数();                    

                     if (参数.length == 构造函数S.length) {

                         for (int j = 0; j < 参数.length; j++) {

                             if (参数[j].getClass().toString().equals(构造函数S[j].toString())) {

                                 if ( j == 参数.length - 1) {

                                     Constructor cons = 组件类.getConstructor(构造函数S);

                                     return (组件) cons.newInstance(参数);

                                 }

                             } else break;

                         }

                     }

                     continue;

                 }

                 throw new Exception ("没有找到对应的组件");

             } else

                 return (组件) 组件类.newInstance();

         } catch (Exception e) {

             e.printStackTrace();

             throw new Exception ("没有找到对应的组件");

         }

     }

}

class 客户系统显示 {

     private 文本 text;

     private 标签 label;

     public static void main(String args[]) {

         客户系统显示 clientOS = new 客户系统显示();

         组件工厂 factory = new 组件工厂();

         try {

             Object [] params = {"初始化文本", new Integer(20)};

             clientOS.text = (文本) factory.生产组件(组件注册表.Linux_文本,params);

             clientOS.label = (标签) factory.生产组件(组件注册表.Linux_标签,null);

             System.out.println(clientOS.label);

             System.out.println(clientOS.text);

             Object [] params2 = {"初始化"};

             clientOS.text = (文本) factory.生产组件(组件注册表.Linux_文本,params2);

             System.out.println(clientOS.text);

         } catch (Exception e) {

             e.printStackTrace();

         }

     }

}