继SSH简单搭建之后[url] http://yangxinxyx.iteye.com/blog/1003139[/url]
在此贴出一些实践的小小心得的部分代码，以望指正：
现在一个最简单的需求，person类的简单的CRUD。
先进行DAO配置，这里采用Spring的HibernateDaoSupport，这样可以省去过去写HibernateUtil的时间，其实写出来也差不多，有兴趣可以去看一下HibernateDaoSupport的内部实现。
这里先概括的说一下实践的思路：
1.写一个DAO接口，然后用Service来进行实现
2.将DAO加入Spring依赖管理
3.业务层进行DAO隔离，业务层主要是一些事务级别的控制与管理
4.展示层，展示层进行对封装好的业务层进行调用，此层尽量避免过多的业务逻辑，尽量的以展示数据为核心.
(目前有许多分层的实践，但要看具体的项目而定，对于此小项目，这样的松耦合关系是足够了)
具体代码实现：
1.建模
Person.java
Java代码
[JAVA]
public class Person extends BaseModel {
//序列化，防止在传输过程中数据的丢失，保证对象一致性，这点在跨域传输等相等重要
private static final long serialVersionUID = -6233679845518009118L;
private String username;
private int age;
private String gender;
private String mail;
//省去 getter(),setter方法，只是不想代码过于冗余..
[/JAVA]
这里继承了BaseModel类，在BaseModel中会有一个对象通用的字段,和一些通用的方法体，往往在实例化的时候更加方便的进行对象加载和管理
BaseModel.java
Java代码
[JAVA]
public class BaseModel implements Serializable {
private static final long serialVersionUID = 6631951381791286275L;
private int id;
private int version;
private String note;
private Date date;
private String status;
private String beanName;
//实例化
public BaseModel()
{
this.date = new Date();
this.version = 0;
}
//省去getter(),setter()方法
[/JAVA]
Person.hbm.xml:
Xml代码
[XML]
<class name=”staff.Model.Person” table=”person”>
<id name=”id” column=”id”>
<generator/>
</id>
<property name=”name” column=”name”/>
<property name=”age” column=”age”/>
<property name=”gender” column=”gender”/>
<property name=”mail” column=”mail”/>
<property name=”date” column=”date”/>
<property name=”version” column=”version”/>
[/XML]
2.将hbm加入Hibernate配置表
Xml代码
[XML]
<mapping resource=”staff/Model/Person.hbm.xml”/>
[/XML]
3.构造DAO与Service,实现简单的CRUD
PersonDAO.java
[JAVA]
public interface PersonDAO {
public boolean CreatePerson(Person person);
[/JAVA]
PersonService.java
[JAVA]
public class PersonService extends BaseDAO implements PersonDAO{
public boolean CreatePerson(Person person) {
try {
this.getHibernateTemplate().save(person);
} catch (Exception e) {
return false;}
return true;
}
[/JAVA]
这里引入了BaseDAO的东东，用于统一进行DAO管理，可以加一些通用方法.
BaseDAO.java
[JAVA]
public class BaseDAO extends HibernateDaoSupport {//采用HibernateDaoSupport
protected final static Log logger = LogFactory.getLog(BaseDAO.class);
}
[/JAVA]
DAO依赖管理:
applicationContext-DAO.xml
[XML]
<!–在BaseDAO中引入sessionFactory，其它的DAO就引入BaseDAO进行依赖传递–>
<bean id=”baseDAO”>
<property name=”sessionFactory” ref=”sessionFactory”/>
</bean>
<!–personDAO依赖管理–>
<bean id=”personDAO” parent=”baseDAO”/>
[/XML]
4.构造业务层，进行事务管理
PersonAO.java
[JAVA]
public class PersonAO extends BaseAO{
private PersonDAO personDAO;
public Results CreatePerson(Person person){
Results results = new Results();
if(person!=null){
if(personDAO.CreatePerson(person))
{
//DAO交互正常，设标志为TRUE，同时将实体存入body中，方便展示层调用
results.setSuccess(Results.SUCCESS);
results.setBody(person);
}
else{
//DAO 交互异常，设标志为False,同时加入错误特征码，加入错误信 息 results.setSuccess(Results.FAILURE); results.setErrorCode(Results.EXCUTE_ERROR);
results.setMessage(“Create Person error!”);
logger.error(results.getMessage());
}
}
else{
results.setErrorCode(Results.NULL_POINT);
}
return results;
}
//set方法是必需的，因为没有使用Spring的annoation的注解，所以必需手动set
public void setPersonDAO(PersonDAO personDAO) {
this.personDAO = personDAO;
}
}
[/JAVA]
这里引入了BaseAO,和Results类.
BaseAO,主要是对AO进行统一的管理的过滤，同时如果做AOP的话，也可以方便切入
Results,这里主要是一个结果封装类，由于AO上面一层就是展现层，那么一定要保证数据的可读性，以及完整性，同时也要将一些出错信息包装起来，以加强人性化。
对于Results主要封的数据有：
1.object,List,Map,Collections….也就是一个数据接收器
2.Message,信息异常接收器
3.Flag，标志位，用以判断交互过程是否出现问题.
Results.java:
[JAVA]
public final static boolean SUCCESS=true;
public final static boolean FAILURE=false;
public final static int EXECUTE_SUCCESS= 1;
public final static int QUERY_SUCCESS = 2;
public final static int NULL_POINT = 3;
public final static int EXCUTE_ERROR = 4;
private boolean success;
private String message;
private int errorCode;
private Object body;
private List<Object> list;
@SuppressWarnings(“unchecked”)
private Map resultMap = new HashMap();//实例化，防止空指针异常
//构造方法..以满足各种构造情况
public Results(){}
public Results(boolean isSuccess,int errorCode){
this.success=isSuccess;
this.errorCode=errorCode;
}
public Results(boolean isSuccess)
{
this.success = isSuccess;
}
public Results(boolean isSuccess,String message)
{
this.success= isSuccess;
this.message = message;
}
public Results(boolean isSuccess, int errorCode, Object body) {
this.success=isSuccess;
this.errorCode=errorCode;
this.body = body;
}
public Results(boolean isSuccess,int errorCode,List<Object> list)
{
this.success= isSuccess;
this.errorCode = errorCode;
this.setList(list);
}
public int getErrorCode() {
return errorCode;
}
public boolean isSuccess() {
return success;
}
public void setSuccess(boolean success) {
this.success = success;
}
public void setMessage(String message)
{
this.message = message;
}
public String getMessage()
{
return message;
}
public void setErrorCode(int errorCode) {
this.errorCode = errorCode;
}
public Object getBody() {
return body;
}
public void setBody(Object body) {
this.body = body;
}
public Object getResult(Object key) {
return resultMap.get(key);
}
@SuppressWarnings(“unchecked”)
public void putResult(Object k,Object v){
resultMap.put(k,v);
}
@SuppressWarnings(“unchecked”)
public void putAll(Map map){
resultMap.putAll(map);
}
@SuppressWarnings(“unchecked”)
public Map getAll(){
return resultMap;
}
public void setList(List<Object> list) {
this.list = list;
}
public List<Object> getList() {
return list;
}
[/JAVA]
加入AO依赖，同时加入事务管理:
applicationContext-AO.xml:
[XML]
<!–配置personAO依赖关系–>
<bean id=”personAO” scope=”prototype”/>
<!–配置事务控制–>
<bean id=”transactionInterceptor” >
<!– 为事务拦截器bean注入一个事物管理器 –>
<property name=”transactionManager” ref=”transactionManager”></property>
<property name=”transactionAttributes”>
<!– define the transaction level –>
<props>
<prop key=”insert*”>PROPAGATION_REQUIRED</prop>
<prop key=”update*”>PROPAGATION_REQUIRED</prop>
<prop key=”save*”>PROPAGATION_REQUIRED</prop>
<prop key=”add*”>PROPAGATION_REQUIRED</prop>
<prop key=”remove*”>PROPAGATION_REQUIRED</prop>
<prop key=”delete*”>PROPAGATION_REQUIRED</prop>
<prop key=”get*”>PROPAGATION_REQUIRED,readOnly</prop>
<prop key=”find*”>PROPAGATION_REQUIRED,readOnly</prop>
<prop key=”load*”>PROPAGATION_REQUIRED,readOnly</prop>
<prop key=”change*”>PROPAGATION_REQUIRED</prop>
<prop key=”login*”>PROPAGATION_REQUIRED</prop><!–
<prop key=”*”>PROPAGATION_REQUIRED,readOnly</prop>
–></props>
</property>
</bean>
<!–事务管理会自动进行事务拦截，同时赋于相应的事务级别，但这点在好像在Spring集成测试中没有体现出来，也许没有进行一个完整的加载–>
[/XML]
5.构造展现层，整合Struts
PersonAction.java
[JAVA]
public class PersonAction extends BaseAction {
private PersonVO person;
private PersonAO personAO;
private String message;
public String createPerson(){
if(person!=null){
Person personDO = new Person();
personDO.setGender(person.getGender());
personDO.setMail(person.getMail());
personDO.setName(person.getName());
Results rs = personAO.CreatePerson(personDO);
if(rs.isSuccess()){
session.put(“person”,rs.getBody());
return SUCCESS;
}else{
message = “系统忙，请稍后再试”;
return INPUT;
}
}else{
message = “输入信息为空”;
return INPUT;
}
}
public void setPersonAO(PersonAO personAO) {
this.personAO = personAO;
}
public PersonVO getPerson() {
return person;
}
public void setPerson(PersonVO person) {
this.person = person;
}
public String getMessage() {
return message;
}
public void setMessage(String message) {
this.message = message;
}
[/JAVA]
这里和前面一样有一个BaseAction的这种类进行统一的过滤的管理，同时这里建立了一个VO类，作为展示层的数据接收器，同时和MODEL相分离，里面的属性几乎和MODEL类一样，但因具体需求可能会有所更改.
Message属性作为消息传输，将人性化的异常信息传送到前台，同时也可以作为AJAX接入.
BaseAction.java
[JAVA]
public class BaseAction extends ActionSupport implements SessionAware {
private static final long serialVersionUID = -5789339746366878811L;
protected Map<String ,Object> session;
public Map<String, Object> getSession() {
return session;
}
public void setSession(Map arg0) {
this.session = arg0;
}
}
[/JAVA]
在BaseAction里面引入一个用于Action处理的ActionSupport,这是Struts2的核心类，另外引入一个相同得要的 SessionAware，通过实现这个接口，ACTION可以获得一个session,在展现层中进行传输，同时重写接口默认方法.这样在所有的 BaseAction继承类中，都可以随意进行session的获取和设值.
applicationContext-Action.xml:
[xml]
<bean id=”personAction” scope=”prototype”/>
[/xml]
至此，每一层的配置已完成，当然还有Struts的MAPPING还需要配置，这里随意的写一个Struts的Mapper:
在Struts.xml中配置如下信息
[xml]
<package name=”person” extends=”struts-default” namespace=”/person”>
<action name=”register” method=”register”>
<result name=”success”>/WEB-INF/jsp/person/personInfo.jsp</result>
<result name=”input”>/WEB-INF/jsp/person/register.jsp</result>
<result type=”redirectAction” name=”error”>/WEB-INF/jsp/error.jsp</result>
</action>
</package>
[/xml]
6.尾声-远远不止如此
至此基本框架搭建完毕，当然如有兴趣，你还可以做如下的一些东西：
1.搭建Spring的集成测试环境
2.配置Log4j
3.配置velocity等模板语言
4.配置siteMesh等视图模板
5.配置Struts过滤器，字符转换器，国际化
6.配置Application级预加载缓存
7.优化Hibernate缓存