spring学习总结(mybatis，事务，测试JUnit4，日志log4j&slf4j，定时任务quartz&spring-task，jetty，Restful-jersey等)

在实战中学习，模仿博客园的部分功能。包括用户的注册，登陆；发表新随笔，阅读随笔；发表评论，以及定时任务等。Entity层设计3张表，分别为user表(用户)，essay表(随笔)以及comment表(评论)。表结构如下：

项目开发采用Intellij IDEA + maven，整个项目结构如下如下图所示：

在项目的pom.xml文件中，导入项目需要的依赖。pom.xml内容如下所示:

  1 <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  2          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
  3     <modelVersion>4.0.0</modelVersion>
  4     <groupId>spring_demo2</groupId>
  5     <artifactId>com.everSeeker</artifactId>
  6     <packaging>war</packaging>
  7     <version>1.0</version>
  8     <name>com.everSeeker Maven Webapp</name>
  9     <url>http://maven.apache.org</url>
 10
 11     <properties>
 12         <spring.version>4.2.4.RELEASE</spring.version>
 13         <jetty.version>9.3.7.v20160115</jetty.version>
 14         <slf4j.version>1.7.14</slf4j.version>
 15         <jersey.version>1.19</jersey.version>
 16     </properties>
 17
 18     <dependencies>
 19
 20         <!--数据库相关, mysql, mybatis-->
 21         <dependency>
 22             <groupId>mysql</groupId>
 23             <artifactId>mysql-connector-java</artifactId>
 24             <version>5.1.38</version>
 25         </dependency>
 26         <dependency>
 27             <groupId>org.mybatis</groupId>
 28             <artifactId>mybatis</artifactId>
 29             <version>3.3.0</version>
 30         </dependency>
 31         <dependency>
 32             <groupId>org.mybatis</groupId>
 33             <artifactId>mybatis-spring</artifactId>
 34             <version>1.2.3</version>
 35         </dependency>
 36
 37         <!--数据源配置, dataSource-->
 38         <dependency>
 39             <groupId>c3p0</groupId>
 40             <artifactId>c3p0</artifactId>
 41             <version>0.9.1.2</version>
 42         </dependency>
 43
 44         <!--事务相关, transcationManager-->
 45         <dependency>
 46             <groupId>org.springframework</groupId>
 47             <artifactId>spring-jdbc</artifactId>
 48             <version>${spring.version}</version>
 49         </dependency>
 50
 51         <!--可以找到使用Spring ApplicationContext特性时所需的全部类，JDNI 所需的全部类，instrumentation组件以及校验Validation 方面的相关类。外部依赖spring-beans, (spring-aop)。-->
 52         <!--提供基于注解的配置, 比如@Component, @Service, @Repository, @Controller等-->
 53         <dependency>
 54             <groupId>org.springframework</groupId>
 55             <artifactId>spring-context</artifactId>
 56             <version>${spring.version}</version>
 57         </dependency>
 58         <dependency>
 59             <groupId>org.springframework</groupId>
 60             <artifactId>spring-context-support</artifactId>
 61             <version>${spring.version}</version>
 62         </dependency>
 63         <dependency>
 64             <groupId>org.springframework</groupId>
 65             <artifactId>spring-tx</artifactId>
 66             <version>${spring.version}</version>
 67         </dependency>
 68
 69         <!--测试-->
 70         <dependency>
 71             <groupId>junit</groupId>
 72             <artifactId>junit</artifactId>
 73             <version>4.12</version>
 74             <scope>test</scope>
 75         </dependency>
 76         <dependency>
 77             <groupId>org.springframework</groupId>
 78             <artifactId>spring-test</artifactId>
 79             <version>${spring.version}</version>
 80         </dependency>
 81
 82         <!--任务调度-->
 83         <dependency>
 84             <groupId>org.quartz-scheduler</groupId>
 85             <artifactId>quartz</artifactId>
 86             <version>2.2.1</version>
 87         </dependency>
 88
 89         <!--log4j && slf4j-->
 90         <dependency>
 91             <groupId>org.slf4j</groupId>
 92             <artifactId>slf4j-api</artifactId>
 93             <version>${slf4j.version}</version>
 94         </dependency>
 95         <dependency>
 96             <groupId>org.slf4j</groupId>
 97             <artifactId>slf4j-log4j12</artifactId>
 98             <version>${slf4j.version}</version>
 99         </dependency>
100         <dependency>
101             <groupId>org.slf4j</groupId>
102             <artifactId>jcl-over-slf4j</artifactId>
103             <version>${slf4j.version}</version>
104             <scope>runtime</scope>
105         </dependency>
106
107         <!--jetty相关-->
108         <dependency>
109             <groupId>org.eclipse.jetty</groupId>
110             <artifactId>jetty-server</artifactId>
111             <version>${jetty.version}</version>
112         </dependency>
113         <dependency>
114             <groupId>org.eclipse.jetty</groupId>
115             <artifactId>jetty-servlet</artifactId>
116             <version>${jetty.version}</version>
117         </dependency>
118         <dependency>
119             <groupId>org.eclipse.jetty</groupId>
120             <artifactId>jetty-webapp</artifactId>
121             <version>${jetty.version}</version>
122         </dependency>
123         <dependency>
124             <groupId>org.eclipse.jetty</groupId>
125             <artifactId>jetty-servlets</artifactId>
126             <version>${jetty.version}</version>
127         </dependency>
128
129         <!--jersey-->
130         <dependency>
131             <groupId>com.sun.jersey</groupId>
132             <artifactId>jersey-core</artifactId>
133             <version>${jersey.version}</version>
134         </dependency>
135         <dependency>
136             <groupId>com.sun.jersey.contribs</groupId>
137             <artifactId>jersey-spring</artifactId>
138             <version>${jersey.version}</version>
139             <exclusions>
140                 <exclusion>
141                     <artifactId>spring-core</artifactId>
142                     <groupId>org.springframework</groupId>
143                 </exclusion>
144                 <exclusion>
145                     <artifactId>spring-beans</artifactId>
146                     <groupId>org.springframework</groupId>
147                 </exclusion>
148                 <exclusion>
149                     <artifactId>spring-context</artifactId>
150                     <groupId>org.springframework</groupId>
151                 </exclusion>
152                 <exclusion>
153                     <artifactId>spring-web</artifactId>
154                     <groupId>org.springframework</groupId>
155                 </exclusion>
156                 <exclusion>
157                     <artifactId>spring-aop</artifactId>
158                     <groupId>org.springframework</groupId>
159                 </exclusion>
160             </exclusions>
161         </dependency>
162         <dependency>
163             <groupId>com.sun.jersey</groupId>
164             <artifactId>jersey-server</artifactId>
165             <version>${jersey.version}</version>
166         </dependency>
167         <dependency>
168             <groupId>com.sun.jersey</groupId>
169             <artifactId>jersey-servlet</artifactId>
170             <version>${jersey.version}</version>
171         </dependency>
172         <dependency>
173             <groupId>com.sun.jersey</groupId>
174             <artifactId>jersey-json</artifactId>
175             <version>${jersey.version}</version>
176         </dependency>
177
178         <!--用来将POJO序列化为JSON对象-->
179         <dependency>
180             <groupId>org.glassfish.jersey.media</groupId>
181             <artifactId>jersey-media-json-jackson</artifactId>
182             <version>2.22.2</version>
183         </dependency>
184
185     </dependencies>
186
187     <build>
188         <finalName>com.everSeeker</finalName>
189     </build>
190
191 </project>

注：以下所有介绍，第一步都是在pom.xml文件中导入相关依赖。之后文章中不再说明。

下面开始详细介绍。

一、Mybatis

1、先做准备工作。在mysql数据库中创建表。

 1 create database if NOT EXISTS spring_demo default character set utf8;
 2 use spring_demo;
 3 show engines;
 4
 5 create table if not exists user(id int primary key not null auto_increment, username varchar(12) not null, password varchar(20), score int, ranking int, essay_count int, UNIQUE(username)) engine=InnoDB;
 6 show table status like 'user'\G;
 7
 8 create table if not exists essay(id int primary key not null auto_increment, title varchar(40) not null, create_date datetime, user_id int, reading_count int, comment_count int, tag varchar(40), UNIQUE(title)) engine=InnoDB;
 9 show table status like 'essay'\G;
10
11 create table if not exists comment(id int PRIMARY KEY NOT NULL AUTO_INCREMENT, content TEXT, user_id int, essay_id int, comment_date DATETIME) ENGINE=InnoDB;
12 show table status like 'comment'\G;

sql

2、在entity目录下创建与数据库中表对应的类，以user表为例。

 1 package com.everSeeker.entity;
 2
 3 import java.io.Serializable;
 4
 5 /**
 6  * 对象的序列化 class implements Serializable
 7  * 参考文档：http://www.cnblogs.com/xudong-bupt/archive/2013/05/19/3086493.html
 8  */
 9 public class User implements Serializable {
10     private int id;
11     private String username;
12     private String password;
13     private int score;
14     private int ranking;
15     private int essayCount;
16
17     public User() {}
18
19     public User(String username, String password) {
20         this.username = username;
21         this.password = password;
22         score = 0;
23         ranking = 0;
24         essayCount = 0;
25     }
26
27     public int getId() {
28         return id;
29     }
30
31     public void setId(int id) {
32         this.id = id;
33     }
34
35     public String getUsername() {
36         return username;
37     }
38
39     public void setUsername(String username) {
40         this.username = username;
41     }
42
43     public String getPassword() {
44         return password;
45     }
46
47     public void setPassword(String password) {
48         this.password = password;
49     }
50
51     public int getScore() {
52         return score;
53     }
54
55     public void setScore(int score) {
56         this.score = score;
57     }
58
59     public int getRanking() {
60         return ranking;
61     }
62
63     public void setRanking(int ranking) {
64         this.ranking = ranking;
65     }
66
67     public int getEssayCount() {
68         return essayCount;
69     }
70
71     public void setEssayCount(int essayCount) {
72         this.essayCount = essayCount;
73     }
74
75     @Override
76     public String toString() {
77         return "User [id=" + id + ", username=" + username + ", password=" + password + ", score=" + score +
78                 ", rankding=" + ranking + ", essayCount=" + essayCount + "]";
79     }
80 }

User.java

3、在dao目录下创建操作数据表的接口，以userDao为例。

 1 package com.everSeeker.dao;
 2
 3 import com.everSeeker.entity.User;
 4 import org.apache.ibatis.annotations.Param;
 5 import org.springframework.stereotype.Repository;
 6
 7 @Repository
 8 public interface UserDao {
 9
10     void addUser(@Param("user") User user);
11
12     User getUserById(int id);
13
14     User getUserByUsername(String username);
15
16     void updateUser(User user);
17
18     void rankingByScore();
19 }

UserDao.java

4、为使用mybatis管理操作数据库，首先需要设置spring与mybatis配合使用的相关配置。

mybatis.xml：在本项目中，仅仅用作给实体类配置别名。

spring-mybatis.xml：在本项目中，用来配置数据源dataSource，sqlSessionFactory等。

具体文件内容如下：

 1 <?xml version="1.0" encoding="UTF-8" ?>
 2 <!DOCTYPE configuration
 3         PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd">
 4
 5 <configuration>
 6
 7        <!--配置实体类的别名-->
 8        <typeAliases>
 9               <!--以下2种方法选其一即可。 第1种方法：使用typeAlias，为单个类设置别名。-->
10               <typeAlias type="com.everSeeker.entity.User" alias="User" />
11               <typeAlias type="com.everSeeker.entity.Essay" alias="Essay" />
12               <typeAlias type="com.everSeeker.entity.Comment" alias="Comment" />
13               <!--第2种方法：使用package，为包下面的所有类设置别名，默认规则为com.everSeeker.entity.User设置为User，去除前面的包名。-->
14               <!--<package name="com.everSeeker.entity" />-->
15        </typeAliases>
16
17 </configuration>

mybatis.xml

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <beans xmlns="http://www.springframework.org/schema/beans"
 3        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 4        xmlns:tx="http://www.springframework.org/schema/tx"
 5        xmlns:p="http://www.springframework.org/schema/p"
 6        xsi:schemaLocation="http://www.springframework.org/schema/beans
 7                           http://www.springframework.org/schema/beans/spring-beans-3.1.xsd
 8                           http://www.springframework.org/schema/tx
 9                           http://www.springframework.org/schema/tx/spring-tx-3.1.xsd">
10
11        <!--数据源配置 c3p0
12            常见的数据源实现类包有2个，一个是apache的DBCP(org.apache.commons.dbcp.BasicDataSource)，另一个为C3P0。
13        -->
14        <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"
15              destroy-method="close">
16
17               <property name="driverClass" value="${db.mysql.driverClass}" />
18               <property name="jdbcUrl" value="${db.mysql.jdbcUrl}" />
19               <property name="user" value="${db.mysql.user}" />
20               <property name="password" value="${db.mysql.password}" />
21
22               <!--连接池中保留的最小连接数。 -->
23               <property name="minPoolSize" value="${db.minPoolSize}" />
24
25               <!--连接池中保留的最大连接数。Default: 15 -->
26               <property name="maxPoolSize" value="${db.maxPoolSize}" />
27
28               <!--初始化时获取的连接数，取值应在minPoolSize与maxPoolSize之间。Default: 3 -->
29               <property name="initialPoolSize" value="${db.initialPoolSize}" />
30
31               <!--最大空闲时间,60秒内未使用则连接被丢弃。若为0则永不丢弃。Default: 0 -->
32               <property name="maxIdleTime" value="${db.maxIdleTime}" />
33
34               <!--当连接池中的连接耗尽的时候c3p0一次同时获取的连接数。Default: 3 -->
35               <property name="acquireIncrement" value="${db.acquireIncrement}" />
36
37               <!--JDBC的标准参数，用以控制数据源内加载的PreparedStatements数量。但由于预缓存的statements 属于单个connection而不是整个连接池。所以设置这个参数需要考虑到多方面的因素。
38                   如果maxStatements与maxStatementsPerConnection均为0，则缓存被关闭。Default: 0 -->
39               <property name="maxStatements" value="${db.maxStatements}" />
40
41               <!--每60秒检查所有连接池中的空闲连接。Default: 0 -->
42               <property name="idleConnectionTestPeriod" value="${db.idleConnectionTestPeriod}" />
43
44               <!--定义在从数据库获取新连接失败后重复尝试的次数。Default: 30 -->
45               <property name="acquireRetryAttempts" value="${db.acquireRetryAttempts}" />
46
47               <!--获取连接失败将会引起所有等待连接池来获取连接的线程抛出异常。但是数据源仍有效 保留，并在下次调用getConnection()的时候继续尝试获取连接。如果设为true，那么在尝试
48                   获取连接失败后该数据源将申明已断开并永久关闭。Default: false -->
49               <property name="breakAfterAcquireFailure" value="${db.breakAfterAcquireFailure}" />
50
51               <!--因性能消耗大请只在需要的时候使用它。如果设为true那么在每个connection提交的 时候都将校验其有效性。建议使用idleConnectionTestPeriod或automaticTestTable
52                   等方法来提升连接测试的性能。Default: false -->
53               <property name="testConnectionOnCheckout" value="${db.testConnectionOnCheckout}" />
54        </bean>
55
56        <!-- myBatis配置.
57             classpath和classpath*的区别，参考文档：http://blog.csdn.net/zl3450341/article/details/9306983.
58             classpath只会返回第一个匹配的资源，建议确定路径的单个文档使用classpath；匹配多个文档时使用classpath*.
59        -->
60        <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean"
61              p:dataSource-ref="dataSource"
62              p:configLocation="classpath:mybatis.xml"
63              p:mapperLocations="classpath*:com/everSeeker/*Mapper.xml" />
64
65        <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
66               <!--basePackage指定要扫描的包，在此包之下的映射器都会被搜索到。可指定多个包，包与包之间用逗号或分号分隔
67                   MapperScannerConfigurer将扫描basePackage所指定包下的所有接口类(包括子包)，如果他们在SQL映射文件
68                   中定义过，则将他们动态定义为一个Spring Bean. -->
69               <property name="basePackage" value="com.everSeeker.dao" />
70               <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory" />
71               <!--<property name="annotationClass" value="com.everSeeker.dao" />-->
72        </bean>
73
74        </beans>

spring-mybatis.xml

在spring-mybatis.xml文件中，引入了db.properties文件中的内容。

 1 # Database
 2 db.mysql.driverClass = com.mysql.jdbc.Driver
 3 db.mysql.jdbcUrl = jdbc:mysql://localhost:3306/spring_demo?useUnicode=true&characterEncoding=utf-8&allowMultiQueries=true
 4 db.mysql.user = root
 5 db.mysql.password = 333
 6 db.minPoolSize = 10
 7 db.maxPoolSize = 100
 8 db.initialPoolSize = 20
 9 db.maxIdleTime = 60
10 db.acquireIncrement = 5
11 db.maxStatements = 100
12 db.idleConnectionTestPeriod = 60
13 db.acquireRetryAttempts = 30
14 db.breakAfterAcquireFailure = true
15 db.testConnectionOnCheckout = false

db.properties

最后，在spring.xml配置文件中载入与mybatis相关的配置文件。

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <beans xmlns="http://www.springframework.org/schema/beans"
 3        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 4        xmlns:context="http://www.springframework.org/schema/context"
 5        xsi:schemaLocation="http://www.springframework.org/schema/beans
 6                            http://www.springframework.org/schema/beans/spring-beans.xsd
 7                            http://www.springframework.org/schema/context
 8                            http://www.springframework.org/schema/context/spring-context.xsd">
 9
10     <!-- 加载Spring配置文件 -->
11     <context:property-placeholder location="classpath:db.properties"/>
12     <context:property-placeholder location="classpath:log4j.properties"/>
13
14     <import resource="classpath:spring-mybatis.xml"/>
15
16     <!-- 使用spring annotation自动扫描配置 -->
17     <context:component-scan base-package="com.everSeeker"/>
18     <!-- 自动注入 -->
19     <context:annotation-config/>
20
21 </beans>

5、准备工作已经完成，现在就可以通过在**Mapper.xml文件中以直接写sql语句的方式来操作数据库并同时实现dao层中相关类的接口了。以UserDao为例，在resources/com/everSeeker目录下创建对应的UserMapper.xml文件。

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
 3
 4 <mapper namespace="com.everSeeker.dao.UserDao">
 5     <resultMap id="ResultMapUser" type="com.everSeeker.entity.User">
 6         <id column="id" property="id"/>
 7         <result column="username" property="username"/>
 8         <result column="password" property="password"/>
 9         <result column="score" property="score"/>
10         <result column="ranking" property="ranking"/>
11         <result column="essay_count" property="essayCount"/>
12     </resultMap>
13
14     <insert id="addUser" parameterType="User">
15         INSERT INTO user(username, password, score, ranking, essay_count) VALUES(#{user.username}, #{user.password}, #{user.score}, #{user.ranking}, #{user.essayCount})
16     </insert>
17
18     <select id="getUserById" parameterType="int" resultMap="ResultMapUser">
19         SELECT * FROM user WHERE id=#{id}
20     </select>
21
22     <select id="getUserByUsername" parameterType="String" resultMap="ResultMapUser">
23         SELECT * FROM user where username=#{username}
24     </select>
25
26     <update id="updateUser" parameterType="User">
27         UPDATE user SET username=#{username}, password=#{password}, score=#{score}, ranking=#{ranking}, essay_count=#{essayCount} where id=#{id}
28     </update>
29
30     <!--在mysql中执行多条语句，可以采用存储过程，如{call proc()}；也可以通过连接数据库时设置allowMultiQueries=true来实现-->
31     <update id="rankingByScore">
32         --         { call proc() }
33         SET @row=0;
34         UPDATE user SET ranking=(@row:=@row+1) ORDER BY score DESC;
35     </update>
36 </mapper>

6、更多关于mybatis的内容参考：

1) http://www.mybatis.org/mybatis-3/zh/index.html

2) 如果数据表中的column字段和modal(entity)中定义的类的字段不一致，比如数据库中User表有字段t_username,而在类User中定义字段username,则可以使用ResultMap来代替ResultType。详细信息可参考MyBatis中关于resultType和resultMap的区别以及MyBatis魔法堂：ResultMap详解以及MyBatis魔法堂：即学即用篇。

二、事务

在spring中实现事务可以很简单。只需要配置好事务管理器，之后给需要事务处理的类或者方法直接通过@Transactional注解即可。

1、在本项目中，通过在spring-mybatis.xml文件中配置事务管理。

 1 <!-- 事务管理器配置, 使用jdbc事务 -->
 2        <bean id="transactionManager"
 3              class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
 4               <property name="dataSource" ref="dataSource" />
 5        </bean>
 6
 7        <!-- 使用annotation定义事务，对标注了@Transactional注解的bean进行处理，以织入事务管理切面.
 8            默认情况下，自动使用名称为transactionManager的事务管理器。
 9            proxy-target-class为true，表示spring将通过创建子类来代理业务类，需要在类路径中添加CGLib.jar类库。-->
10        <tx:annotation-driven transaction-manager="transactionManager"
11                              proxy-target-class="true" />

2、给需要事务处理的类或者方法通过@Transactional注解。以CommentServiceImpl.java为例，对类中所有方法进行事务处理。publicNewComment方法为发表新的评论，需要在comment表中新增一条评论的记录，之后在essay表中对被评论的随笔评论数＋1，同时还需要在user表中对随笔的作者score＋10分，这3个操作组合成了一个原子操作，需要进行事务处理。

 1 package com.everSeeker.service.impl;
 2
 3 import com.everSeeker.dao.CommentDao;
 4 import com.everSeeker.dao.EssayDao;
 5 import com.everSeeker.dao.UserDao;
 6 import com.everSeeker.entity.Comment;
 7 import com.everSeeker.entity.Essay;
 8 import com.everSeeker.entity.User;
 9 import com.everSeeker.service.CommentService;
10 import org.springframework.stereotype.Service;
11 import org.springframework.transaction.annotation.Transactional;
12
13 import javax.annotation.Resource;
14
15 @Service("commentService")
16 @Transactional
17 public class CommentServiceImpl implements CommentService {
18     @Resource
19     private CommentDao commentDao;
20     @Resource
21     private EssayDao essayDao;
22     @Resource
23     private UserDao userDao;
24
25     public void publishNewComment(Comment comment) {
26         //comment表中新增一条记录
27         commentDao.addComment(comment);
28         //essay表comment_count+1
29         Essay essay = essayDao.getEssayById(comment.getEssayId());
30         if(essay != null) {
31             essay.setCommentCount(essay.getCommentCount() + 1);
32             essayDao.updateEssay(essay);
33             //user表随笔作者对应的记录score+10
34             User user = userDao.getUserById(essay.getUserId());
35             if(user != null) {
36                 user.setScore(user.getScore() + 10);
37                 userDao.updateUser(user);
38             }
39         }
40     }
41 }

三、JUnit4测试

使用JUnit4可以很方便的进行单元测试。假设我们需要对UserService类中的各个方法进行测试，只需要在test/com/everSeeker/service目录下新建测试类TestUserService即可。

1、在测试类前面新增2个注解：

@RunWith(SpringJUnit4ClassRunner.class)

@ContextConfiguration(locations = {"/spring.xml"})

@RunWith：加载JUnit4。

@ContextConfiguration：加载spring配置文件，是一个字符串数组，可以加载多个配置文件。

2、在具体方法前新增注解@Test。

TestUserService.java关键内容如下：

 1 package com.everSeeker.service;
 2
 3 import com.everSeeker.dao.UserDao;
 4 import com.everSeeker.entity.User;
 5 import org.junit.Test;
 6 import org.junit.runner.RunWith;
 7 import org.springframework.test.annotation.Rollback;
 8 import org.springframework.test.context.ContextConfiguration;
 9 import org.springframework.test.context.junit4.AbstractTransactionalJUnit4SpringContextTests;
10 import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
11
12 import javax.annotation.Resource;
13
14
15 @RunWith(SpringJUnit4ClassRunner.class)
16 @ContextConfiguration(locations = {"/spring.xml"})
17 public class TestUserService extends AbstractTransactionalJUnit4SpringContextTests {
18
19     @Resource
20     private UserService userService;
21
22     @Resource
23     private UserDao userDao;
24
25     /**
26      * AbstractTransactionalJUnit4SpringContextTests默认回滚。如果需要修改为不回滚设置为false即可。
27      * 默认回滚的主要目的是避免产生脏数据。但是如果数据库主键采取自增模式的话，实质上对数据库还是有一点影响。如果主键采取UUID就没这个问题。
28      */
29     @Test
30     @Rollback(false)
31     public void TestAddUser() {
32         User user = new User("ponpon7", "888888");
33         userService.addUser(user);
34     }
35
36     @Test
37     public void TestGetUserByUsername() {
38         System.out.println(userService.getUserByUsername("ppp"));
39     }
40 }

四、日志(log4j & slf4j)

1、关键是配置好log4j.properties文件。

 1 #更多详情请参考：
 2 #http://www.cnblogs.com/pigtail/archive/2013/02/16/2913195.html
 3 #http://it.oyksoft.com/log4j/
 4
 5 #此句为将等级为INFO的日志信息输出到stdout和R这两个目的地，stdout和R的定义在下面的代码，可以任意起名。
 6 #等级可分为OFF、FATAL、ERROR、WARN、INFO、DEBUG、ALL，如果配置OFF则不打出任何信息，
 7 #如果配置为INFO这样只显示INFO, WARN, ERROR的log信息，而DEBUG信息不会被显示，具体讲解可参照第三部分定义配置文件中的logger。
 8 log4j.rootCategory = INFO, R, stdout
 9
10 #此句为定义名为stdout的输出端是哪种类型，可以是
11 #org.apache.log4j.ConsoleAppender（控制台），
12 #org.apache.log4j.FileAppender（文件），
13 #org.apache.log4j.DailyRollingFileAppender（每天产生一个日志文件），
14 #org.apache.log4j.RollingFileAppender（文件大小到达指定尺寸的时候产生一个新的文件）
15 #org.apache.log4j.WriterAppender（将日志信息以流格式发送到任意指定的地方）
16 log4j.appender.stdout = org.apache.log4j.ConsoleAppender
17
18 #此句为定义名为stdout的输出端的layout是哪种类型，可以是
19 #org.apache.log4j.HTMLLayout（以HTML表格形式布局），
20 #org.apache.log4j.PatternLayout（可以灵活地指定布局模式），
21 #org.apache.log4j.SimpleLayout（包含日志信息的级别和信息字符串），
22 #org.apache.log4j.TTCCLayout（包含日志产生的时间、线程、类别等等信息）
23 #具体讲解可参照第三部分定义配置文件中的Layout。
24 log4j.appender.stdout.layout = org.apache.log4j.PatternLayout
25
26 #如果使用pattern布局就要指定的打印信息的具体格式ConversionPattern，打印参数如下：
27 #%m 输出代码中指定的消息
28 #%p 输出优先级，即DEBUG，INFO，WARN，ERROR，FATAL
29 #%r 输出自应用启动到输出该log信息耗费的毫秒数
30 #%c 输出所属的类目，通常就是所在类的全名
31 #%t 输出产生该日志事件的线程名
32 #%n 输出一个回车换行符，Windows平台为“rn”，Unix平台为“n”
33 #%d 输出日志时间点的日期或时间，默认格式为ISO8601，也可以在其后指定格式，比如：%d{yyyy MMM dd HH:mm:ss,SSS}，输出类似：2002年10月18日 22：10：28，921
34 #%l 输出日志事件的发生位置，包括类目名、发生的线程，以及在代码中的行数。
35 #[QC]是log信息的开头，可以为任意字符，一般为项目简称。
36 log4j.appender.stdout.layout.ConversionPattern = [%p]-[%t]-[%l]-[%d{yyyyMMdd HH:mm:ss}]%n%m%n
37
38 #将日志信息存入文件中
39 log4j.appender.R = org.apache.log4j.DailyRollingFileAppender
40 log4j.appender.R.Threshold = INFO
41 log4j.appender.R.File = /Users/pingping/Projects/IdeaProjects/cnblogs/spring_demo2/logs/output.log
42 log4j.appender.R.DatePattern = '.'yyyy-MM-dd
43 log4j.appender.R.Append = true
44 log4j.appender.R.layout = org.apache.log4j.PatternLayout
45 log4j.appender.R.layout.ConversionPattern = [%p]-[%t]-[%l]-[%d{yyyyMMdd HH:mm:ss}]%n%m%n

更多详细信息可参考：

http://www.cnblogs.com/pigtail/archive/2013/02/16/2913195.html

http://it.oyksoft.com/log4j/

2、直接使用即可，以UserServiceImpl.java为例。

 1 package com.everSeeker.service.impl;
 2
 3 import com.everSeeker.dao.UserDao;
 4 import com.everSeeker.entity.User;
 5 import com.everSeeker.service.UserService;
 6 import org.slf4j.Logger;
 7 import org.slf4j.LoggerFactory;
 8 import org.springframework.stereotype.Service;
 9
10 import javax.annotation.Resource;
11
12 @Service("userService")
13 public class UserServiceImpl implements UserService {
14     @Resource
15     private UserDao userDao;
16
17     private static Logger log = LoggerFactory.getLogger(UserServiceImpl.class);
18
19     public void addUser(User user) {
20         userDao.addUser(user);
21     }
22
23     public User getUserByUsername(String username) {
24         User user = userDao.getUserByUsername(username);
25         log.info("All info about {}: \n{}", username, user);
26         return user;
27     }
28
29     public int checkUser(String username, String password) {
30         log.info("start check username: {}", username);
31         User user = userDao.getUserByUsername(username);
32         if (user == null) {
33             log.warn("username is incorrect!");
34             return 10;
35         }
36         if (!user.getPassword().equals(password)) {
37             log.warn("passowrd is incorrect!");
38             return 100;
39         }
40         log.info("{} has successed checked!", username);
41         return 1;
42     }
43 }

五、定时任务(Quartz & spring-task)

主要介绍目前主流的2种在指定时间执行或者按某个频率自动执行的实现方式。

1、spring-task：采用@Scheduled注解方式，配置简单，使用灵活方便。

2、quartz：配置稍微复杂，功能强大。

下面以具体代码详细说明。

首先，新创建spring-task.xml配置文件，具体内容如下：

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <beans xmlns="http://www.springframework.org/schema/beans"
 3        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 4        xmlns:task="http://www.springframework.org/schema/task"
 5        xsi:schemaLocation="http://www.springframework.org/schema/beans
 6                            http://www.springframework.org/schema/beans/spring-beans.xsd
 7                            http://www.springframework.org/schema/task
 8                            http://www.springframework.org/schema/task/spring-task-3.0.xsd"
 9        default-lazy-init="false">
10
11        <!--开启定时任务的2种方法，（1）通过spring－task，采用@Scheduled注解方式，配置简单，使用灵活方便；
12                                （2）通过quartz，配置稍微复杂，功能强大 -->
14
15        <!--方法一：-->
16        <!--开启task:annotation-driven，spring可以通过注解@Scheduled来开启任务-->
17        <task:executor id="executor" pool-size="5"/>
18        <task:scheduler id="scheduler" pool-size="10"/>
19        <task:annotation-driven executor="executor" scheduler="scheduler"/>
20
21        <!--方法二：-->
22        <!--配置作业类-->
23        <bean id="quartzTask" class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">
24               <property name="targetObject">
25                      <bean class="com.everSeeker.task.QuartzTask"/>
26               </property>
27               <property name="targetMethod" value="rankingByScore"/>
28               <property name="concurrent" value="false"/>
29        </bean>
30        <!--配置触发器-->
31        <!--关于cronExpression, 请参考： http://www.cnblogs.com/yaowen/p/3779284.html-->
32        <bean id="cronTrigger" class="org.springframework.scheduling.quartz.CronTriggerFactoryBean">
33               <property name="jobDetail" ref="quartzTask"/>
34               <!--每隔10s执行一次-->
35               <property name="cronExpression" value="0/10 * * * * ?"/>
36        </bean>
37        <!--配置调度工厂-->
38        <bean class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
39               <property name="triggers">
40                      <list>
41                             <ref bean="cronTrigger"/>
42                      </list>
43               </property>
44        </bean>
45
46 </beans>

在com/everSeeker/task目录下新建2个文件QuartzTask.java以及SpringTask.java，分别用来测试quartz以及spring-task。

QuartzTask.java

 1 package com.everSeeker.task;
 2
 3 import com.everSeeker.dao.UserDao;
 4 import org.springframework.stereotype.Service;
 5
 6 import javax.annotation.Resource;
 7
 8 @Service
 9 public class QuartzTask {
10     @Resource
11     private UserDao userDao;
12
13     public void rankingByScore() {
14         System.out.println("通过quartz, 每隔10s执行一次任务。。。");
15 //        userDao.rankingByScore();
16     }
17 }

SpringTask.java

 1 package com.everSeeker.task;
 2
 3 import com.everSeeker.dao.UserDao;
 4 import org.springframework.scheduling.annotation.Scheduled;
 5 import org.springframework.stereotype.Component;
 6
 7 import javax.annotation.Resource;
 8
 9 @Component("springTask")
10 public class SpringTask {
11
12     @Resource
13     private UserDao userDao;
14
15     @Scheduled(cron = "0/20 * * * * ?")
16     public void rankingByScoreJob() {
17         System.out.println("通过spring-task，每隔20秒执行一次任务。。。");
18         System.out.println("----------------------------------------");
19 //        userDao.rankingByScore();
20     }
21 }

六、jetty

jetty需要定义Server, Connector以及至少一个handler, ThreadPool可选。

先定义自己的handler，内容是输出"hello jetty"。

 1 public class MyHandler extends AbstractHandler {
 2
 3     public void handle(String target, Request baseRequest, HttpServletRequest request, HttpServletResponse response)
 4         throws IOException, ServletException {
 5         response.setContentType("text/html;charset=utf-8");
 6         response.setStatus(HttpServletResponse.SC_OK);
 7         baseRequest.setHandled(true);
 8         response.getWriter().println("<h1>Hello jetty</h1>");
 9     }
10 }

之后在Spring配置文件中将Server，Connector以及Handler配置好即可。

 1 # spring-jetty.xml
 2 <bean id="jetty_server" class="org.eclipse.jetty.server.Server" init-method="start" destroy-method="stop">
 3
 4         <!--<property name="threadPool">-->
 5             <!--<bean id="defaultThreadPool" class="org.eclipse.jetty.util.thread.QueuedThreadPool">-->
 6                 <!--<property name="minThreads" value="10"/>-->
 7                 <!--<property name="maxThreads" value="100"/>-->
 8             <!--</bean>-->
 9         <!--</property>-->
10
11         <property name="connectors">
12             <list>
13                 <bean id="Connector" class="org.eclipse.jetty.server.ServerConnector">
14                     <constructor-arg name="server"><ref bean="jetty_server"/></constructor-arg>
15                     <property name="port" value="8080"/>
16                 </bean>
17             </list>
18         </property>
19
20         <property name="handler">
21             <bean id="handlers" class="org.eclipse.jetty.server.handler.HandlerList">
22                 <property name="handlers">
23                     <list>
24                         <bean class="com.everSeeker.jetty.MyHandler"/>
25                         <!--<bean class="com.everSeeker.jetty.RestfulHandler"/>-->
26                         <bean class="org.eclipse.jetty.server.handler.DefaultHandler"/>
27                     </list>
28                 </property>
29             </bean>
30         </property>
31
32     </bean>

在网页中打开输入网址, http://localhost:8080，页面显示为"hello jetty"。

更多详情请参考：

http://www.eclipse.org/jetty/documentation/current/index.html

http://hbiao68.iteye.com/blog/2111007

http://www.cnblogs.com/windlaughing/archive/2013/06/07/3125358.html

七、Restful(jersey)

实现Restful的框架很多，本案例采用的是jersey.

首先建立一个jetty服务，并指定要处理jersey资源的包名com.everSeeker.action，然后启动jetty。

public class App {
    public static void main(String[] args) throws  Exception {
        Server server = new Server(8080);
        ServletHolder servlet = new ServletHolder(ServletContainer.class);
        servlet.setInitParameter("com.sun.jersey.config.property.resourceConfigClass", "com.sun.jersey.api.core.PackagesResourceConfig");
        servlet.setInitParameter("com.sun.jersey.config.property.packages", "com.everSeeker");
        ServletContextHandler handler = new ServletContextHandler(ServletContextHandler.SESSIONS);
        handler.setContextPath("/");
        handler.addServlet(servlet, "/*");
        server.setHandler(handler);
        server.start();
        server.join();
    }
}

之后在包com.everSeeker.action下新建Restful类，以UserAction.java为例。

 1 @Component
 2 @Path("/user")
 3 public class UserAction {
 4
 5     /**
 6      * 如果userService不采用getBean方式获得的话，即直接写成private UserService userService，会报空指针错误。
 7      * 通过debug方式查看会发现，userService=null，没有注入成功，原因暂时还不知道，请高手告知。
 8      */
 9     @Resource
10     private UserService userService = SpringContextUtils.getApplicationContext().getBean(UserServiceImpl.class);
11
12     /**
13      * @GET : get请求
14      * @Path : 路径,由于类的路径为/user,所以该方法的路径为/user/{username}
15      * @Produces : 返回类型。该方法为文本。
16      * @Consumes : 可以接受的类型。
17      */
18     @GET
19     @Path("{username}")
20     @Produces(MediaType.TEXT_PLAIN)
21     public String getByUsername(@PathParam("username") String username) throws Exception {
22         return userService.getUserByUsername(username).toString();
23     }
24
25     /**
26      * 返回的类型为json。需要将类User转换为json格式。本案例采用的转换方式为jackson, 在pom.xml中有说明。
27      */
28     @GET
29     @Path("json/{username}")
30     @Produces(MediaType.APPLICATION_JSON)
31     public User getUserByUsername(@PathParam("username") String username) throws Exception {
32         return userService.getUserByUsername(username);
33     }
34 }

更多信息请参考：

https://jersey.java.net/nonav/documentation/latest/index.html

http://www.zhaochao.net/index.php/2015/12/07/5/

http://waylau.com/jersey-2-spring-4-rest/

代码清单请见个人github。地址：https://github.com/ponpon7/spring_demo2。

http://www.cnblogs.com/everSeeker/p/5188840.html