利用SpringSide 3.1.4.3开拓Web项目标全进程（上）

副标题#e#

SpringSide 3.1.4.3是今朝SpringSide的最新版本，也是完成度较量高的一 个版本，用来做实际项目标开拓应该丝绝不成问题。这里写一下利用该版本开拓 一个简朴Web项目标全进程，虽然，最重要的是我本身的一些心得体会。我的文 章很长，只有耐下性子细看，才气体会其中三味。

第一步、下载SpringSide 3.1.4.3 all-in-one版。这个进程太简朴了， SpringSide的官方网站是www.springside.org.cn，去哪里就可以下载了，all- in-one版虽然是懒人们的不二选择。这里有一点很搞笑，该版本标的是 SpringSide 3.1.4.3，可是下载后解压缩，解压缩出来的文件是springside- 3.1.4.2，这大概是江南白衣的一点小小的失误，据我揣摩，3.1.4.3较3.1.4.1 的进步应该是插手了jsp-api.jar这一个库，但愿白衣这次不要为了变动这个版 本号上的失误而再推出一个新版本，假如然要推出新版本，怎么样也应该把我最 近研究出来的大都据库的设置加进去。

第二步、安装SpringSide。假如安装过SpringSide以前的版本，最好把用户 目次下的.m2文件夹删掉，这个文件夹是Maven的当地客栈地址地，虽说Maven可 以有效担保库文件不会产生版本斗嘴，可是删除这个文件夹会使安装进程加速，不然，SpringSide的安装进程会不断询问你是否包围某某文件。删除.m2文件夹 后，运行springside-3.1.4.2目次下的bin目次中的quickstart.bat即可（前提 条件是已经安装好了JDK5或以上版本，假如你的电脑中连JDK都没有，就别来趟 SpringSide的浑水了）。 期待这个文件运行完，就可以看到SpringSide 3提供 的三个示例项目mini-web、mini-service、showcase都运行起来了，这时你可以 细细体会一下SpringSide实现的各类特性。

仔细察看SpringSide的bin目次，发明该版本提供的剧本越发明晰和有用，如 start-db.bat可以用来启动Derby数据库，start-selenium.bat用来启动 selenium server，而start-tomcat.bat那就别说了，地球人都知道。

假如要想利用SpringSide来生成项目，尚有一点点小事情要做，就是把Maven 的bin目次插手到PATH情况变量中，如下图：

第三步，利用SpringSide生成项目。运行bin目次下的new-project.bat即可 ，如下图：

#p#副标题#e#

在建设项目标进程中，该剧本会提出一些问题，个中groupId指的是你的组织 的名称，由于该项目由我私人孝敬，纯属示范用，所以我填了 youxia.personal ，因此，在第5个问题上，我选择了personal.you作为我项目中的package的名字 ，这也是切合国际老例的；artifactId指的是项目标名字，这里为 MultiDatasourceExample，名字有点长，从名字就可以看出来我要示范多个数据 源的设置。

第四步、启动Eclipse，导入项目。 生成的项目位于SpringSide目次下的 tools\generator\generated-project目次下，下面是Eclipse的截图：

项目导入乐成后，Eclispe资源打点器的截图：

#p#副标题#e#

可以看到，该项目一经导入，当即可用，一个烦人 的红叉都没有，这也正说明白该版本是SpringSide 3的一个革命性版本，从该版 本开始，SpringSide 3的易用性提高了不止一个档次。

Eclipse推荐 利用3.4及以上版本，因为在该版本中，对Tomcat处事器的打点越发利便，只需 要在项目标快捷菜单中选择Run On Server，即可自动打开Tomcat处事器并陈设 项目，如下图：

这里有一点必然要留意，由于SpringSide生成的项目默认利用的是Derby 数据库，所以要想乐成运行项目，必需先启动Derby数据库，还记得前面提到的 start-db.bat吗？运行它！然后运行该项目标bin目次下的init-db.jar，在数据 库中放入该项目标初始化数据。

然后就可以点Run On Server来启动 项目了，让各人见地一下Eclipse的嵌入式欣赏器、Tomcat处事器视图、Console 视图。真的是太利便了：

#p#副标题#e#

第五步、将数据库迁移到MySQL中。在项目中，建设数据库和初始化数据库的 语句都是以SQL文件存在的，如下图：

可是该语句都是针对Derby的，假如要应用于MySQL，还必需得要做一些修改 才行，先修改schema.sql，如下：

#p#分页标题#e#

drop　table　if　exists　RESOURCES_AUTHORITIES;
drop　table　if　exists　ROLES_AUTHORITIES;
drop　table　if　exists　USERS_ROLES;
drop　table　if　exists　RESOURCES;
drop　table　if　exists　AUTHORITIES;
drop　table　if　exists　USERS;
drop　table　if　exists　ROLES;
create　table　USERS　(
ID　integer　primary　key　auto_increment,
LOGIN_NAME　varchar(20)　not　null　unique,
PASSWORD　varchar(20),
NAME　varchar(20),
EMAIL　varchar(30)
);
create　unique　index　USERS_LOGIN_NAME_INDEX　on　USERS (LOGIN_NAME);
create　table　ROLES　(
ID　integer　primary　key　auto_increment,
NAME　varchar(20)　not　null　unique
);
create　table　USERS_ROLES　(
USER_ID　integer　not　null,
ROLE_ID　integer　not　null,
FOREIGN　KEY　(ROLE_ID)　references　ROLES(ID),
FOREIGN　KEY　(USER_ID)　references　USERS(ID)
);
CREATE　TABLE　AUTHORITIES　(
ID　integer　primary　key　auto_increment,
NAME　varchar(20)　not　null,
DISPLAY_NAME　varchar(20)　not　null
);
create　table　ROLES_AUTHORITIES　(
ROLE_ID　integer　not　null,
AUTHORITY_ID　integer　not　null,
FOREIGN　KEY　(ROLE_ID)　references　ROLES(ID),
FOREIGN　KEY　(AUTHORITY_ID)　references　AUTHORITIES(ID)
);
CREATE　TABLE　RESOURCES　(
ID　integer　primary　key　auto_increment,
RESOURCE_TYPE　varchar(20)　not　null,
VALUE　varchar(255)　not　null,
ORDER_NUM　float　not　null
);
create　table　RESOURCES_AUTHORITIES　(
AUTHORITY_ID　integer　not　null,
RESOURCE_ID　integer　not　null,
FOREIGN　KEY　(AUTHORITY_ID)　references　AUTHORITIES(ID),
FOREIGN　KEY　(RESOURCE_ID)　references　RESOURCES(ID)
);

#p#副标题#e#

该修改主要包括两个处所，一个是在drop table后头加上了if exists，一个 是把GENERATED ALWAYS as IDENTITY修改为auto_increment。而load-data.sql 不需要修改。

然后，启动MySQL，在MySQL中利用上面的两个sql文件建设数据库和添加初始 化数据，如下图：

然后变动数据库毗连，修改项目标application.properties文件，如下：

#jdbc　settings
jdbc.url=jdbc:mysql://localhost:3306/MultiDatasourceExample? useUnicode=true&characterEncoding=utf8
jdbc.username=youxia
jdbc.password=******
#hibernate　settings
hibernate.show_sql=false
hibernate.format_sql=false
hibernate.ehcache_config_file=/ehcache/ehcache-hibernate- local.xml

#p#副标题#e#

修改项目标applicationContext.xml文件，这里要修改两个处所，一个为 DriverClassName，一个为hibernate.dilect，如下：

<?xml　version="1.0"　encoding="UTF-8"?>
<beans　xmlns="http://www.springframework.org/schema/beans"　 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
　　　　 xmlns:jee="http://www.springframework.org/schema/jee"　 xmlns:tx="http://www.springframework.org/schema/tx"
　　　　 xmlns:context="http://www.springframework.org/schema/context"
　　　　 xsi:schemaLocation="http://www.springframework.org/schema/beans　 http://www.springframework.org/schema/beans/spring-beans-2.5.xsd　 http://www.springframework.org/schema/tx　 http://www.springframework.org/schema/tx/spring-tx-2.5.xsd　 http://www.springframework.org/schema/jee　 http://www.springframework.org/schema/jee/spring-jee-2.5.xsd　 http://www.springframework.org/schema/context　 http://www.springframework.org/schema/context/spring-context- 2.5.xsd"
　　　　 default-lazy-init="true">
　　　　 <description>Spring民众设置文件　</description>
　　　　 <!--　界说受情况影响易变的变量　-->
　　　　 <bean　 class="org.springframework.beans.factory.config.PropertyPlaceholderCon figurer">
　　　　　　　　 <property　name="systemPropertiesModeName"　 value="SYSTEM_PROPERTIES_MODE_OVERRIDE"　/>
　　　　　　　　 <property　name="ignoreResourceNotFound"　value="true"　/>
　　　　　　　　 <property　name="locations">
　　　　　　　　　　　　 <list>
　　　　　　　　　　　　　　　　 <!--　尺度设置　-->
　　　　　　　　　　　　　　　　 <value>classpath*:/application.properties</value>
　　　　　　　　　　　　　　　　 <!--　当地开拓情况设置　-->
　　　　　　　　　　　　　　　　 <value>classpath*:/application.local.properties</value>
　　　　　　　　　　　　　　　　 <!--　处事器出产情况设置　-->
　　　　　　　　　　　　　　　　 <!--　 <value>file:/var/myapp/application.server.properties</value&g t;　-->
　　　　　　　　　　　　 </list>
　　　　　　　　 </property>
　　　　 </bean>
　　　　 <!--　利用annotation　自动注册bean,并担保@Required,@Autowired的属性 被注入　-->
　　　　 <context:component-scan　base-package="personal.youxia"　/>
　　　　 <!--　数据源设置,利用应用内的DBCP数据库毗连池　-->
　　　　 <bean　id="dataSource"　 class="org.apache.commons.dbcp.BasicDataSource"　destroy- method="close">
　　　　　　　　 <!--　Connection　Info　-->
　　　　　　　　 <property　name="driverClassName"　 value="com.mysql.jdbc.Driver"　/>
　　　　　　　　 <property　name="url"　value="${jdbc.url}"　/>
　　　　　　　　 <property　name="username"　value="${jdbc.username}"　/>
　　　　　　　　 <property　name="password"　value="${jdbc.password}"　/>
　　　　　　　　 <!--　Connection　Pooling　Info　-->
　　　　　　　　 <property　name="initialSize"　value="5"　/>
　　　　　　　　 <property　name="maxActive"　value="100"　/>
　　　　　　　　 <property　name="maxIdle"　value="30"　/>
　　　　　　　　 <property　name="maxWait"　value="1000"　/>
　　　　　　　　 <property　name="poolPreparedStatements"　value="true"　/>
　　　　　　　　 <property　name="defaultAutoCommit"　value="false"　/>
　　　　 </bean>
　　　　 <!--　数据源设置,利用应用处事器的数据库毗连池　-->
　　　　 <!--<jee:jndi-lookup　id="dataSource"　jndi- name="java:comp/env/jdbc/ExampleDB"　/>-->
　　　　 <!--　Hibernate设置　-->
　　　　 <bean　id="sessionFactory"　 class="org.springframework.orm.hibernate3.annotation.AnnotationSession FactoryBean">
　　　　　　　　 <property　name="dataSource"　ref="dataSource"　/>
　　　　　　　　 <property　name="namingStrategy">
　　　　　　　　　　　　 <bean　class="org.hibernate.cfg.ImprovedNamingStrategy"　/>
　　　　　　　　 </property>
　　　　　　　　 <property　name="hibernateProperties">
　　　　　　　　　　　　 <props>
　　　　　　　　　　　　　　　　 <prop　 key="hibernate.dialect">org.hibernate.dialect.MySQL5InnoDBDialect&l t;/prop>
　　　　　　　　　　　　　　　　 <prop　key="hibernate.show_sql">${hibernate.show_sql} </prop>
　　　　　　　　　　　　　　　　 <prop　key="hibernate.format_sql">${hibernate.format_sql} </prop>
　　　　　　　　　　　　　　　　 <prop　 key="hibernate.cache.provider_class">org.hibernate.cache.EhCachePro vider
　　　　　　　　　　　　　　　　 </prop>
　　　　　　　　　　　　　　　　 <prop　 key="hibernate.cache.provider_configuration_file_resource_path">${h ibernate.ehcache_config_file}</prop>
　　　　　　　　　　　　 </props>
　　　　　　　　 </property>
　　　　　　　　 <property　name="packagesToScan"　value="personal.youxia.entity.*" 　/>
　　　　 </bean>
　　　　 <!--　事务打点器设置,单数据源事务　-->
　　　　 <bean　id="transactionManager"　 class="org.springframework.orm.hibernate3.HibernateTransactionManager" >
　　　　　　　　 <property　name="sessionFactory"　ref="sessionFactory"　/>
　　　　 </bean>
　　　　 <!--　事务打点器设置,大都据源JTA事务-->
　　　　 <!--
　　　　　　　　 <bean　id="transactionManager"　 class="org.springframework.transaction.jta.JtaTransactionManager　 or
　　　　　　　　 WebLogicJtaTransactionManager"　/>
　　　　 -->
　　　　 <!--　利用annotation界说事务　-->
　　　　 <tx:annotation-driven　transaction- manager="transactionManager"　/>
</beans>

#p#分页标题#e#

由于SpringSide不提供Mysql的jdbc驱动，所以需要本身去MySQL的官方网站 下载，将下载到的mysql-connector-5.*.jar复制到项目标WEB-INF中的lib目次 中。然后运行项目，乐成。至此，乐成将项目迁移到MySQL中。

#p#副标题#e#

#p#分页标题#e#

第六步、添加数据表、编写Entity类、编写Dao类、Manager类，并举办单位 测试。照旧以前几篇文章中提到的文章宣布系统为例，每一篇文章对应多篇评论 ，所以说据库中需建设articles和comments两个数据表，如下：

create　　　table　　articles(
id　　int　　　primary　　　key　　auto_increment,
subject　　varchar　(　20　)　　not　　　null　,
content　　text　);
create　　　table　　comments(
id　　int　　　primary　　　key　　auto_increment,
content　　varchar　(　255　),
article_id　　int　　　not　　　null　,
foreign　　　key　　(article_id)　　references　　articles(id)
);

在编写Java代码之前，我还要做一点小事情，什么事情呢？那就是要为我自 己的项目建设一个单独的源文件夹，因为src\main\java这个文件夹已经被江南 白衣放入了太多的package，并且因为涉及到security，所以条理也不明明，操 作起来不利便，找起代码来也不足快。下面是我建设了本身的源文件夹后的截图 ：

在我本身的源文件夹中，只建设了四个package，恰好代表从底到上的四个层 次，这样，找起代码来要利便得多。

先来Entity层，Article.java的代码如下：

package　personal.youxia.entity;
import　java.util.LinkedHashSet;
import　java.util.Set;
import　javax.persistence.CascadeType;
import　javax.persistence.Entity;
import　javax.persistence.JoinColumn;
import　javax.persistence.OneToMany;
import　javax.persistence.OrderBy;
import　javax.persistence.Table;
import　org.hibernate.annotations.Cache;
import　org.hibernate.annotations.CacheConcurrencyStrategy;
import　org.hibernate.annotations.Fetch;
import　org.hibernate.annotations.FetchMode;
@Entity
//　表名与类名不沟通时从头界说表名.
@Table(name　=　"articles")
//　默认的缓存计策.
@Cache(usage　=　CacheConcurrencyStrategy.READ_WRITE)
public　class　Article　extends　IdEntity　{
　　　　 private　String　subject;
　　　　 private　String　content;
　　　　 private　Set<Comment>　comments　=　new　 LinkedHashSet<Comment>();
　　　　 public　String　getSubject()　{
　　　　　　　　 return　subject;
　　　　 }
　　　　 public　void　setSubject(String　subject)　{
　　　　　　　　 this.subject　=　subject;
　　　　 }
　　　　 public　String　getContent()　{
　　　　　　　　 return　content;
　　　　 }
　　　　 public　void　setContent(String　content)　{
　　　　　　　　 this.content　=　content;
　　　　 }
　　　　 @OneToMany(cascade　=　{　CascadeType.ALL　})
　　　　 @JoinColumn(name　=　"article_id")
　　　　 //　Fecth计策界说
　　　　 @Fetch(FetchMode.SUBSELECT)
　　　　 //　荟萃按id排序.
　　　　 @OrderBy("id")
　　　　 //　荟萃中工具id的缓存.
　　　　 @Cache(usage　=　CacheConcurrencyStrategy.READ_WRITE)
　　　　 public　Set<Comment>　getComments()　{
　　　　　　　　 return　comments;
　　　　 }
　　　　 public　void　setComments(Set<Comment>　comments)　 {
　　　　　　　　 this.comments　=　comments;
　　　　 }
}

#p#副标题#e#

Comment.java如下：

package　personal.youxia.entity.entities;
import　javax.persistence.Column;
import　javax.persistence.Entity;
import　javax.persistence.Table;
import　org.hibernate.annotations.Cache;
import　org.hibernate.annotations.CacheConcurrencyStrategy;
import　personal.youxia.entity.IdEntity;
@Entity
//　表名与类名不沟通时从头界说表名.
@Table(name　=　"comments")
//　默认的缓存计策.
@Cache(usage　=　CacheConcurrencyStrategy.READ_WRITE)
public　class　Comment　extends　IdEntity　{
　　　　 private　String　content;
　　　　 private　Long　articleId;
　　　　 public　String　getContent()　{
　　　　　　　　 return　content;
　　　　 }
　　　　 public　void　setContent(String　content)　{
　　　　　　　　 this.content　=　content;
　　　　 }

　　　　 @Column(name　=　"article_id")
　　　　 public　Long　getArticleId()　{
　　　　　　　　 return　articleId;
　　　　 }
　　　　 public　void　setArticleId(Long　articleId)　{
　　　　　　　　 this.articleId　=　articleId;
　　　　 }
}

编写Dao层代码，ArticleDao.java如下：

#p#分页标题#e#

package　personal.youxia.dao;
import　org.springside.modules.orm.hibernate.HibernateDao;
import　personal.youxia.entity.Article;
public　class　ArticleDao　extends　HibernateDao<Article,　 Long>　{
}

CommentDao.java如下：

package　personal.youxia.dao;
import　org.springside.modules.orm.hibernate.HibernateDao;
import　personal.youxia.entity.Comment;
public　class　CommentDao　extends　HibernateDao<Comment,　 Long>　{
}

可以看出，以上代码都从HibernateDao担任，得益于泛型支持，根基不需要 编写一行代码。

编写Bussiness层代码，这一层，白衣利用的包名为service，而类名的后缀 都是Manager，我就跟他学算了，懒得改了。

ArticleManager.java如下：

package　personal.youxia.service;
import　org.springframework.beans.factory.annotation.Autowired;
import　org.springside.modules.orm.hibernate.HibernateDao;
import　personal.youxia.dao.ArticleDao;
import　personal.youxia.entity.Article;
public　class　ArticleManager　extends　EntityManager<Article,　 Long>　{
　　　　 @Autowired
　　　　 private　ArticleDao　articleDao;
　　　　 public　void　setArticleDao(ArticleDao　articleDao)　{
　　　　　　　　 this.articleDao　=　articleDao;
　　　　 }
　　　　 @Override
　　　　 protected　HibernateDao<Article,　Long>　 getEntityDao()　{
　　　　　　　　 //　TODO　Auto-generated　method　stub
　　　　　　　　 return　articleDao;
　　　　 }
}

#p#副标题#e#

CommentManager.java如下：

package　personal.youxia.service;
import　org.springframework.beans.factory.annotation.Autowired;
import　org.springside.modules.orm.hibernate.HibernateDao;
import　personal.youxia.dao.CommentDao;
import　personal.youxia.entity.Comment;
public　class　CommentManager　extends　EntityManager<Comment,　 Long>　{
　　　　 @Autowired
　　　　 private　CommentDao　commentDao;
　　　　 public　void　setCommentDao(CommentDao　commentDao)　{
　　　　　　　　 this.commentDao　=　commentDao;
　　　　 }
　　　　 @Override
　　　　 protected　HibernateDao<Comment,　Long>　 getEntityDao()　{
　　　　　　　　 //　TODO　Auto-generated　method　stub
　　　　　　　　 return　commentDao;
　　　　 }
}

以上代码大同小异，都是从EntityManager担任，并利用Spring的IoC特性， 将Dao类注入到Manager类之中，并重载 getEntityDao要领来利用该注入的Dao。 这个时候，为了验证这些数据会见相关的层可否正常运行，可以编写单位测试。 代码如下：

package　personal.youxia.test;
import　org.junit.Test;
import　org.springframework.beans.factory.annotation.Autowired;
import　org.springside.modules.test.junit4.SpringTxTestCase;
import　personal.youxia.entity.entities.Article;
import　personal.youxia.entity.entities.Comment;
import　personal.youxia.service.ArticleManager;
import　personal.youxia.service.CommentManager;
public　class　DataAccessTest　extends　SpringTxTestCase　{
　　　　 @Autowired
　　　　 private　ArticleManager　articleManager;
　　　　 @Autowired
　　　　 private　CommentManager　commentManager;
　　　　 public　void　setArticleManager(ArticleManager　 articleManager)　{
　　　　　　　　 this.articleManager　=　articleManager;
　　　　 }
　　　　 @Test
　　　　 public　void　addArticle()　{
　　　　　　　　 Comment　comment　=　new　Comment();
　　　　　　　　 Article　article　=　new　Article();
　　　　　　　　 article.setSubject("test");
　　　　　　　　 article.setContent("test");
　　　　　　　　 articleManager.save(article);
　　　　　　　　 comment.setArticleId(article.getId());
　　　　　　　　 commentManager.save(comment);
　　　　 }
}

#p#分页标题#e#

单位测试一运行，发明白三个问题，先是呈现Manager类没有注入乐成的错误 ，经查抄发明所有的Manager类都应该利用@Service注解，再呈现的错误是提示 Dao类没有注入乐成，经查抄发明所有的Dao类须利用@Repository注解，最后出 现的错误是找不到Entity类的错误，经查抄发明Entity类不能位于 personal.youxia.entity包中，必需位于其子包中，这是由 applicationContext.xml文件中的设置抉择的，变动包名为 personal.youxia.entity.entities后，问题办理。

下一步就应该是编写Action和JSP了，由于文章太长，在Blogjava的编辑器中 编辑已经很是迟钝了，所以只有将该文章分为上中下三部门。且看下回解析！