maven小项目注册服务(一)--email和persist模块

跟着书里的讲解，跟着做了一遍该项目：

首先明白注册账户的需求：

账号的lD和Email地址都可以用来唯一地标识某个用户，而显示名称则用来显示在页面下，方便浏览。注册的时候用户还需要输入两次密码，以确保没有输错，系统则需要负责检查ID和email的唯一性，验证两次输入的密码是否一致，验证码是由系统随机生成的只能由肉眼识别其内容的图片，若输入正确的验证码信息，系统则会进行检查，如果验证码错误。系统会生成并返回新的验证码。所有检查

都没问题了，系统就会生成一个激活链接，并发送到用户的邮箱。单击激活链接后，账户就被激活了，这时账户注册完成，用户可以进行登录。对于一个账户注册服务，还需要考虑一些安全因素，例如，需要在服务器端密文地保存密码，检查密码的强弱程度，更进一步则需要考虑验证码的失效时间，激活链接的失效时间等等。

需求用例：

主要场景：

1、用户访问注册页面

2、系统随机生成验证码图片

3、用户输入ID、Email等注册信息

4、输入验证码

5、提交注册请求

6、系统检查验证码、检查ID的唯一性，检查邮箱是否已被注册、密码和确认密码是否一致

7、系统保存未激活的账户信息

8、系统生成激活连接，发送给用户邮箱

9、用户打开邮箱，访问激活链接

10、系统解析激活连接，激活相关用户

11、用户使用ID和密码登陆

扩展场景：

4a：用户无法看清验证码，请求重新生成    1、跳转到2

6a：系统检测到用户输入的验证码有误        1、提示验证码有错，2、跳转到2

6b：检测到 ID已被注册，邮箱，密码有误    1、提示错误信息，2、跳转到2

从上面可以看出该服务有几个接口：生成验证码图片、处理注册请求、激活账户以及处理登陆请求。

接口结构：

acountService类：

generateCaptchaKey()

generateCaptchaImage(captchakey:string)

signUp(signUpRequest:SignUpRequest)：接收对象，进行验证。如果验证正确。则创建一个末被激活的账户，同时在后台也需要发送一封带有激活链接的邮件。

activate(activationNumber:string)：方法接收一个激活码，查找时应的账户进行激活

login(id:string,password:string)

signUpRequest：包含用户的注册信息，表单信息：id、Email、displayName、password、comfirmpassword、captchaKey、captchaValue。

generateCaptchaKey()的简单解释就是验证码，每个captcha都需要有一个key ,根据这个key ,系统才能得到对应的验证码图片以及实际值。因此，generateCaptchaImage会生成一个captchakey使用这个key再调用generateCaptchaImage方法就能得到验证码图片。验证码的key以及验证码图片被传送到客户端，用户通过肉眼识别再输人验证码的值，伴随着key再传送到服务器端验证，服务器端就可以通过这个key查到正确的验证码值，井与客户端传过来的值进行比对验证。

模块划分：

com.hust.silence.accout.service：系统的核心，它封装了所有下层细节，对外暴露简单的接日，这实际上是一个Facade模式。

com.hust.silence.accout.web：该模块包含所有与web相关的内容，包括jsp等，直接依赖于service模块

com.hust.silence.accout.persist：处理账户信息的持久化，包括增、删、改、查等，根据实现，可以基于数据库或者文件

com.hust.silence.accout.captcha：处理验证码的key生成、图片生成以及验证等

com.hust.silence.accout.email： 处理邮件服务的配置，激活邮件的编写和发送等

配置pom.xml

加入需要的各种spring framework的模块，Greenmail是开源的邮件服务套件，Javax.mail为实现发送的一个类库。从上面的信息我们可以知道，该项目时是com.hust.silence的一个account项目，项目里有一个模块为account-email。

实现Email模块：

account-email只有一个很简单的接口。

public interface AccountEmailService {
	void sendMail(String to, String subject, String htmlText) throws AccountEmailException;
}

public class AccountEmailServiceImpl implements AccountEmailService{
	private JavaMailSender javaMailSender;
	private String systemEmail;

	public void sendMail(String to, String subject, String htmlText)
			throws AccountEmailException {
		// TODO Auto-generated method stub
		try {
			MimeMessage msg = javaMailSender.createMimeMessage();
			MimeMessageHelper msgHelper = new MimeMessageHelper(msg);
			msgHelper.setFrom(systemEmail);
			msgHelper.setTo(to);
			msgHelper.setSubject(subject);
			msgHelper.setText(htmlText);
			javaMailSender.send(msg);
		} catch (Exception e) {
			// TODO: handle exception
			throw new AccountEmailException("fail to send mail",e);
		}
	}
	//实现依赖注入
	public JavaMailSender getJavaMailSender(){
		return javaMailSender;
	}
	public void setJavaMailSender(JavaMailSender javaMailSender){
		this.javaMailSender = javaMailSender;
	}
	public String getSystemEmail(){
		return systemEmail;
	}
	public void setSystememail(String systemEmail){
		this.systemEmail = systemEmail;
	}
}

public class AccountEmailException extends Exception {
	/**
	 *
	 */
	private static final long serialVersionUID = 6514881539290222459L;
	public AccountEmailException(String message) {
		super(message);
	}
	public AccountEmailException(String message, Throwable throwable){
		super(message, throwable);
	}
}

配置文件：

id="propertyConfigurer"：这是springframework用来帮助载入properties文件的组件，代码中表示从classpath的根目录下载入名为account-email.properties文件中的属性。

id="javaMailSender"：定义邮件服务器的一些配置.包括协议、端口、主机，用户名、密码，是否需要认证等属性。这段配置还使用了propertyConfigurer的属性引用，比如host的值为$ { email.host }。之前定义的propertyConfigurer作用就在于此、可以将邮件服务器相关的配置分离到外部的properties文件中，比如可以定义这样一个properties文件。配置javaMailSender使用163：

account-email.properties（在src/test/resources文件夹里）：

email.protocol=smtp

email.host=smtp.163.com

email.port=25

email.username=test@163.com

email.password=password

email.auth=true

email.systemEmail=test@163.com

测试：

只需要测试一个sendMail（）接口，这个就需要准备properties文件，配置并启用一个测试使用的邮件服务器，准备好后，就调用该接口实现邮件发送，然后检查是否发送成功，关闭测试邮件服务器。具体代码：

public class AccountEmailServiceTest {
	private GreenMail greenMail;

	@Before
	public void startMailServer() throws Exception{
		greenMail = new GreenMail(ServerSetup.SMTP);
		greenMail.setUser("1219611916@qq.com", "silence");
		greenMail.start();
	}

	@Test
	public void testSendMail() throws Exception{
		//根据account。xml创建一个spring framework的ApplicationContext
		ApplicationContext ctx = new ClassPathXmlApplicationContext("account_email.xml");
		//从ctx中获取需要测试的ID为accountEmailService的bean并转换成AccountEmailService接口，
		//针对接口的测试是最好的单元测试的实现
		AccountEmailService accout = (AccountEmailService)ctx.getBean("accountEmailService");
		String subject = "Test Subject";
		String htmlText = "<h3>test</h3>";
		accout.sendMail("1219611916@qq.com", subject, htmlText);
		greenMail.waitForIncomingEmail(2000, 1);
		Message[] mags = greenMail.getReceivedMessages();
		assertEquals(1,mags.length);
		assertEquals(subject, mags[0].getSubject());
		assertEquals(htmlText, GreenMailUtil.getBody(mags[0]).trim());
	}

	@After
	public void stopMailServer() throws Exception{
		greenMail.stop();
	}
}

实现persist模块：

该模块负责账户数据的持久化，以XML文件的形式保存账户数据，井支持账户的创建、读取、更新、删除等操作。

配置代码：

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.hust.silence.account</groupId>
 <artifactId>account-persist</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <name>account-persist</name>
  <url>http://maven.apache.org</url>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <dom4j.version>1.6.1</dom4j.version>
    <springframework.version>2.5.6</springframework.version>
  </properties>

  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.7</version>
      <scope>test</test>
    </dependency>
    <dependency>
    	<groupId>dom4j</groupId>
    	<artifactId>dom4j</artifactId>
    	<version>${dom4j.version}</version>
    </dependency>
    <dependency>
    	<groupId>org.springframework</groupId>
    	<artifactId>spring-core</artifactId>
        <version>${springframework.version}</version>
    </dependency>
    <dependency>
    	<groupId>org.springframework</groupId>
    	<artifactId>spring-beans</artifactId>
        <version>${springframework.version}</version>
    </dependency>
    <dependency>
    	<groupId>org.springframework</groupId>
    	<artifactId>spring-context</artifactId>
        <version>${springframework.version}</version>
    </dependency>
  </dependencies>

  <build>
  	<testResources>
  		<testResource>
  			<directory>src/test/resources</directory>
  			<filtering>true</filtering>
  		</testResource>
  	</testResources>
  	<plugins>
  		<plugin>
  			<groupId>org.apache.maven.plugins</groupId>
  			<artifactId>maven-resources-plugin</artifactId>
  			<configuration>
  				<encoding>UTF-8</encoding>
  			</configuration>
  		</plugin>
  	</plugins>
  </build>
</project> 　

dom4j是支持XML操作的，build元素包含testresource是开启资源过滤的，在单元测试中用到。

具体代码：

public interface AccountPersistService {
	Account createAccount(Account account) throws AccountPersistException;
	Account readAccount(String id) throws AccountPersistException;
	Account updateAccount(Account account) throws AccountPersistException;
	void deleteAccount(String id) throws AccountPersistException;
}

public class AccountPersistServiceImpl
    implements AccountPersistService
{
	private static final String ELEMENT_ROOT = "account-persist";
	private static final String ELEMENT_ACCOUNTS = "accounts";
	private static final String ELEMENT_ACCOUNT = "account";
	private static final String ELEMENT_ACCOUNT_ID = "id";
	private static final String ELEMENT_ACCOUNT_NAME = "name";
	private static final String ELEMENT_ACCOUNT_EMAIL = "email";
	private static final String ELEMENT_ACCOUNT_PASSWORD = "password";
	private static final String ELEMENT_ACCOUNT_ACTIVATED = "activated";

    private String file;

    private SAXReader reader = new SAXReader();

    public String getFile()
    {
        return file;
    }

    public void setFile( String file )
    {
        this.file = file;
    }

    public Account createAccount( Account account )
    	throws AccountPersistException
    {
    	Document doc = readDocument();

    	Element accountsEle = doc.getRootElement().element(ELEMENT_ACCOUNTS);

    	accountsEle.add( buildAccountElement( account ) );

    	writeDocument( doc );

    	return account;
    }

    @SuppressWarnings("unchecked")
	public void deleteAccount( String id )
    	throws AccountPersistException
    {
        Document doc = readDocument();

        Element accountsEle = doc.getRootElement().element( ELEMENT_ACCOUNTS );

        for ( Element accountEle : (List<Element>) accountsEle.elements() )
        {
            if ( accountEle.elementText( ELEMENT_ACCOUNT_ID ).equals( id ) )
            {
                accountEle.detach();

                writeDocument( doc );

                return;
            }
        }
    }

    @SuppressWarnings("unchecked")
	public Account readAccount( String id )
    	throws AccountPersistException
    {
        Document doc = readDocument();

        Element accountsEle = doc.getRootElement().element( ELEMENT_ACCOUNTS );

        for ( Element accountEle : (List<Element>) accountsEle.elements() )
        {
            if ( accountEle.elementText( ELEMENT_ACCOUNT_ID ).equals( id ) )
            {
                return buildAccount( accountEle );
            }
        }

        return null;
    }

    public Account updateAccount( Account account )
    	throws AccountPersistException
    {
    	if ( readAccount( account.getId() ) != null )
    	{
    		deleteAccount( account.getId() );

    		return createAccount ( account );
    	}

    	return null;
    }

    private Account buildAccount( Element element )
    {
        Account account = new Account();

        account.setId( element.elementText( ELEMENT_ACCOUNT_ID ) );
        account.setName( element.elementText( ELEMENT_ACCOUNT_NAME ) );
        account.setEmail( element.elementText( ELEMENT_ACCOUNT_EMAIL ) );
        account.setPassword( element.elementText( ELEMENT_ACCOUNT_PASSWORD ) );
        account.setActivated( ( "true".equals( element.elementText( ELEMENT_ACCOUNT_ACTIVATED ) ) ? true : false ) );

        return account;
    }

    private Element buildAccountElement( Account account )
    {
    	Element element = DocumentFactory.getInstance().createElement( ELEMENT_ACCOUNT );

        element.addElement( ELEMENT_ACCOUNT_ID ).setText( account.getId() );
    	element.addElement( ELEMENT_ACCOUNT_NAME ).setText( account.getName() );
    	element.addElement( ELEMENT_ACCOUNT_EMAIL ).setText( account.getEmail() );
    	element.addElement( ELEMENT_ACCOUNT_PASSWORD ).setText( account.getPassword() );
    	element.addElement( ELEMENT_ACCOUNT_ACTIVATED ).setText( account.isActivated() ? "true" : "false" );

    	return element;
    }

    private Document readDocument()
    	throws AccountPersistException
    {
    	File dataFile = new File( file );

    	if( !dataFile.exists() )
    	{
    		dataFile.getParentFile().mkdirs();

    		Document doc = DocumentFactory.getInstance().createDocument();

    		Element rootEle = doc.addElement( ELEMENT_ROOT );

    		rootEle.addElement( ELEMENT_ACCOUNTS );

    		writeDocument( doc );
    	}

        try
        {
            return reader.read( new File( file ) );
        }
        catch ( DocumentException e )
        {
        	throw new AccountPersistException( "Unable to read persist data xml", e );
        }
    }

    private void writeDocument( Document doc )
    	throws AccountPersistException
    {
    	Writer out = null;

        try
        {
            out = new OutputStreamWriter( new FileOutputStream( file ), "utf-8" );

            XMLWriter writer = new XMLWriter( out, OutputFormat.createPrettyPrint() );

            writer.write( doc );
        }
        catch ( IOException e )
        {
        	throw new AccountPersistException( "Unable to write persist data xml", e );
        }
        finally
        {
        	try
        	{
        		if ( out != null)
        		{
        			out.close();
        		}
        	}
        	catch ( IOException e )
        	{
        		throw new AccountPersistException( "Unable to close persist data xml writer", e );
        	}
        }
    }
}

Account是一个简单的类：对变量的读取和设置

private String id;
private String name;
private String email;
private String password;
private boolean activated;　

该测试用例遵守了测试接口而不测试实现这一原则:也就是说，测试代码不能引用实现类，由于测试是从接口用户的角度编写的，这样就能保证接口的用户无须知晓接口的实现细节，既保证了代码的解藕，也促进了代码的设计。

测试代码：这里只给出了读取readAccount的test

public class AccountPersistServiceTest {
	private AccountPersistService service;
	@Before
	public void prepare() throws Exception{
		File persistDataFile = new File("target/persist-classes/persist_data.xml");
		if(persistDataFile.exists()){
			persistDataFile.delete();
		}
		ApplicationContext ctx = new ClassPathXmlApplicationContext("account_persist.xml");
		service = (AccountPersistService) ctx.getBean("accountPersistService");
		Account account = new Account();
		account.setId("ww");
		account.setName("wwss");
		account.setEmail("16@qq.com");
		account.setPassword("####");
		account.setActivated(true);
		service.createAccount(account);
	}
	@Test
	public void testReadAccount() throws Exception{
		Account account = service.readAccount("ww");
		assertEquals("ww",account.getId());
		assertEquals("wwss",account.getName());
		assertEquals("126@qq.com",account.getEmail());
		assertEquals("####",account.getPassword());
		assertTrue(account.isActivated());
	}

}

　　想要将上面的代码单个模块运行成功，还需要给出相应的配置文件，xml文件放在src/main/resources下，properties文件放在src/test/resources。

　　尤其是这里只给出了相应的两个模块的代码，有兴趣的可以继续写完成。

account_email.xml:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">

<bean id="propertyConfigurer"
class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
	<property
	name="location"
	value="classpath:account_email.properties"/>
</bean>

	<bean id="javaMailSender" class="org.springframework.mail.javamail.JavaMailSenderImpl">
		<property name="protocol" value="${email.protocol}"></property>
		<property name="host" value="${email.host}"></property>
		<property name="port" value="${email.port}"></property>
		<property name="username" value="${email.username }"></property>
		<property name="password" value="${email.password }"></property>
		<property name="javaMailProperties" >
			<props>
				<prop key="mail.${email.protocol}.auth">${email.auth}</prop>
			</props>
		</property>
	</bean>

	<bean id="accountEmailService"
	class="com.hust.silence.account.email.AccountEmailServiceImpl">
		<property name="javaMailSender" ref="javaMailSender"></property>
		<property name="systemEmail" value="${email.systemEmail}"></property>
	</bean>

</beans>

　　account_email.properties:

email.protocol=smtp
email.host="127.0.0.1"
email.port="25"
email.username=16@qq.com
email.password=####
email.auth=true
email.systemEmail=16@qq.com