利用全注解实现ssh的一个完整例子

在一个稍大的项目中，通常会有上百个组件，如果这些组件采用xml的bean定义来配置，显然会增加配置文件的体积，查找以及维护起来也不太方便。个人也不喜欢配置那么多的xml文件。下面我们就利用java的注解实现ssh框架，注解相当于一种标记加了注解就等于打上了某种标记，没加，则等于没有某种标记，以后，javac编译器，开发工具包和其他程序可以用反射来了解你的类以及各种元素上有何种标记，看你有什么标记，就去干相应的事，标记可以加载包，类，字段，方法，方法的参数以及局部变量上。关于注解在这里不多说，网上大把资料。

先看看完整的工程目录吧



1.为了使用注解我们需要配置web.xml文件，在web-inf目录下内容如下

[html]
view plaincopy

<?xml
version="1.0"
encoding="UTF-8"?>

<web-app
version="2.5"

xmlns="http://java.sun.com/xml/ns/javaee"

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">
<!-- 加载spring配置文件 -->

<context-param>

<param-name>contextConfigLocation</param-name>

<param-value>

classpath*:applicationContext*.xml

</param-value>

</context-param>

<listener>

<listener-class>

org.springframework.web.context.ContextLoaderListener

</listener-class>

</listener>

<!-- struts2 的配置 -->

<filter>

<filter-name>struts2</filter-name>

<filter-class>

org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter

</filter-class>

<init-param>

<!-- //固定格式-->

<param-name>actionPackages</param-name>

<param-value>com.ssh</param-value>

</init-param>

</filter>

<filter-mapping>

<filter-name>struts2</filter-name>

<url-pattern>/*</url-pattern>

</filter-mapping>

<display-name></display-name>

<welcome-file-list>

<welcome-file>index.jsp</welcome-file>

</welcome-file-list>

</web-app>

2.接下来看看spring和hibernate的配置文件applicationContext.xml

[html]
view plaincopy

<?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:context="http://www.springframework.org/schema/context"

xmlns:aop="http://www.springframework.org/schema/aop"

xmlns:tx="http://www.springframework.org/schema/tx"

xsi:schemaLocation="
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd">
<!-- 使用 annotation -->

<context:annotation-config
/>

<!-- 使用 annotation 自动注册bean,并检查@Controller,
@Service, @Repository注解已被注入 -->

<context:component-scan
base-package="com.ssh"
/>

<!-- 数据库配置 -->

<bean
id="dataSource"

class="org.apache.commons.dbcp.BasicDataSource">

<property
name="driverClassName"

value="com.mysql.jdbc.Driver">

</property>

<property
name="url"

value="jdbc:mysql://localhost:3306/myssh">

</property>

<property
name="username"
value="anan"></property>

<property
name="password"
value="123456"></property>

</bean>

<!-- sessionFactory -->

<bean
id="sessionFactory"

class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean">

<property
name="dataSource">

<ref
bean="dataSource"
/>

</property>

<property
name="hibernateProperties">

<props>

<prop
key="hibernate.dialect">

org.hibernate.dialect.MySQLDialect

</prop>

<prop
key="hibernate.show_sql">true</prop>

<!-- 可以自动创建数据库表(create),不创建(none) -->

<prop
key="hibernate.hbm2ddl.auto">update</prop>

</props>

</property>

<!-- 包扫描的方式加载注解类(推荐) -->

<property
name="packagesToScan">

<list>

<value>com.ssh.*</value>

</list>

</property>

</bean>

<!--JDBC事务管理器,根据你的情况使用不同的事务管理器,如果工程中有Hibernate,就用Hibernate的事务管理器
-->

<bean
id="transactionManager"

class="org.springframework.jdbc.datasource.DataSourceTransactionManager">

<property
name="dataSource">

<ref
local="dataSource"
/>

</property>

</bean>

<!-- 用注解来实现事务管理 -->

<tx:annotation-driven
transaction-manager="transactionManager"
/>

</beans>

基本都有注释了，这里不多说了，需要注意的是如果是自己搞回去用千万记得要改上面的数据库配置。

3.接下来我们再看看struts的配置文件struts.xml

[html]
view plaincopy

<?xml
version="1.0"
encoding="UTF-8"
?>

<!DOCTYPE struts PUBLIC "-//Apache Software Foundation//DTD Struts Configuration 2.1//EN" "http://struts.apache.org/dtds/struts-2.1.dtd">

<struts>

<!-- 开启使用开发模式，详细错误提示 -->

<constant
name="struts.devMode"
value="false"
/>

<!-- 将对象交给spring管理 -->

<constant
name="struts.objectFactory"
value="spring"
/>

<!-- 指定资源编码类型 -->

<constant
name="struts.i18n.encoding"
value="UTF-8"
/>

<!-- 指定每次请求到达，重新加载资源文件 -->

<constant
name="struts.i18n.reload"
value="false"
/>

<!-- 指定每次配置文件更改后，自动重新加载 -->

<constant
name="struts.configuration.xml.reload"
value="false"
/>

<!-- 默认后缀名 -->

<!-- <constant name="struts.action.extension"
value="do,action,jhtml,," /> -->

<!-- Struts Annotation -->

<!-- <constant name="actionPackages"
value="com.test1"/> -->

</struts>

基本上注释写的很详细了吧，我也不是很懂就那样配置着先....

接下来我们就可以安心的写java代码了，先创建如下图所示的包和类



先看看实体类User.java

[java]
view plaincopy

package
com.ssh.user.model;

import
javax.persistence.Column;

import
javax.persistence.Entity;

import
javax.persistence.GeneratedValue;

import
javax.persistence.GenerationType;

import
javax.persistence.Id;

import
javax.persistence.Table;

/**

* 类名称：User

* 类描述：用户信息实体

* 创建人：anan

* 创建时间：2012-12-21 下午10:55:19

* 修改人：anan

* 修改时间：2012-12-21 下午10:55:19

* 修改备注：

* @version

* */

@Entity

@Table(name
= "user")

public
class User {

/**

* 用户id

*/

@Id

@Column(name
= "userId")

@GeneratedValue(strategy
= GenerationType.IDENTITY)

private
int userId;

/**

* 用户名

*/

@Column(name
= "userName", length =
50)

private
String userName;

/**

* 用户登录密码

*/

@Column(name
= "passWord", length =
50)

private
String passWord;

public
int getUserId() {

return
userId;

}

public
void setUserId(int
userId) {

this.userId
= userId;

}

public
String getUserName() {

return
userName;

}

public
void setUserName(String
userName) {

this.userName
= userName;

}

public
String getPassWord() {

return
passWord;

}

public
void setPassWord(String
passWord) {

this.passWord
= passWord;

}

public
User(int userId,
String userName, String passWord) {

this.userId
= userId;

this.userName
= userName;

this.passWord
= passWord;

}

public
User(String userName, String passWord) {

this.userName
= userName;

this.passWord
= passWord;

}

public
User(int userId)
{

this.userId
= userId;

}

public
User() {

}

}

这是一个基本的pojo类，关键看看那几个注解@Entity表示当前类是一个实体，@Table(name = "user")指定这个类映射到数据库的哪一个表，@Column(name = "userId")表示这个属性映射数据库对应表中的那一列...

接下来看看UserDao.java

[java]
view plaincopy

package
com.ssh.user.dao;

import
java.util.List;

import
com.ssh.user.model.User;

/**

* 类名称：UserDao

* 类描述：用户控制dao实现数据库操作接口

* 创建人：anan

* 创建时间：2012-12-21 下午11:05:46

* 修改人：anan

* 修改时间：2012-12-21 下午11:05:46

* 修改备注：

* @version

* */

public
interface UserDao
{

public
void addUser(User
user);

public
void delUser(int
userId);

public
void updateUser(User
user);

public
List<User> selectUser();

public
User getUserByUserId(int
userId);

public
boolean isExitByName(String
userName);

public
boolean isExitByNameAndPass(User
user);

}

这是一个接口指定用户操作，定义一些方法

接下来具体实现这些方法，看UserDaoImpl.java

[java]
view plaincopy

package
com.ssh.user.dao.impl;

import
java.util.ArrayList;

import
java.util.Iterator;

import
java.util.List;

import
org.hibernate.Session;

import
org.hibernate.Transaction;

import
org.springframework.stereotype.Repository;

import
com.ssh.user.dao.UserDao;

import
com.ssh.user.model.User;

import
com.ssh.util.MyHibernateDaoSupport;

/**

* 类名称：UserDaoImpl

* 类描述：用户控制dao实现数据库操作接口实现

* 创建人：anan

* 创建时间：2012-12-21 下午11:07:43

* 修改人：anan

* 修改时间：2012-12-21 下午11:07:43

* 修改备注：

* @version

* */

@Repository("userDao")

public
class UserDaoImpl
extends MyHibernateDaoSupport
implements UserDao{

public
void addUser(User
user) {

Session session =

this.getSession(true);

Transaction tc = (Transaction) session.beginTransaction();

session.save(user);

try
{

tc.commit();

}

catch (Exception e) {

e.printStackTrace();

}

session.close();

}

public
void delUser(int
userId) {

Session session =

this.getSession(true);

Transaction tc = (Transaction) session.beginTransaction();

User u =

new User(userId);

session.delete(u);

try
{

tc.commit();

}

catch (Exception e) {

e.printStackTrace();

}

session.close();

}

public
void updateUser(User
user) {

Session session =

this.getSession(true);

Transaction tc = (Transaction) session.beginTransaction();

session.update(user);

try
{

tc.commit();

}

catch (Exception e) {

e.printStackTrace();

}

session.close();

}

public
List<User> selectUser() {

List<User> users =

new ArrayList<User>();

Session session =

this.getSession(true);

Transaction tc = (Transaction) session.beginTransaction();

List list = session.createQuery("From User").list();

for
(Iterator iterator = list.iterator(); iterator.hasNext();) {

User u = (User) iterator.next();

users.add(u);

}

try
{

tc.commit();

}

catch (Exception e) {

e.printStackTrace();

}

session.close();

return
users;

}

public
User getUserByUserId(int
userId) {

Session session =

this.getSession(true);

Transaction tc = (Transaction) session.beginTransaction();

//load 是说明数据库中一定存在这条记录，没有则报出：ObjectNotFoundException

//get 如果查不到记录，返回的是一个null

User user = (User)session.load(User.class,
userId);

try
{

tc.commit();

}

catch (Exception e) {

e.printStackTrace();

}

session.close();

return
user;

}

public
boolean isExitByName(String
userName) {

Session session =

this.getSession(true);

Transaction tc = (Transaction) session.beginTransaction();

List user = (List)session.createQuery("From User
u where u.userName=:userName").setString("userName",
userName).list();

if(user.size()>0){

try
{

tc.commit();

}

catch (Exception e) {

e.printStackTrace();

}

session.close();

return
true;

}

try
{

tc.commit();

}

catch (Exception e) {

e.printStackTrace();

}

session.close();

return
false;

}

public
boolean isExitByNameAndPass(User
user) {

Session session =

this.getSession(true);

Transaction tc = (Transaction) session.beginTransaction();

List users = (List)session.createQuery("From User
u where u.userName=:userName and u.passWord=:passWord").setString("userName",
user.getUserName()).setString("passWord", user.getPassWord()).list();

if(users.size()>0){

try
{

tc.commit();

}

catch (Exception e) {

e.printStackTrace();

}

session.close();

return
true;

}

try
{

tc.commit();

}

catch (Exception e) {

e.printStackTrace();

}

session.close();

return
false;

}

}

到这里数据库操作基本搞完，接下来写业务逻辑代码，先看看UserService.java

[java]
view plaincopy

package
com.ssh.user.service;

import
java.util.List;

import
com.ssh.user.model.User;

/**

* 类名称：UserService

* 类描述：用户业务逻辑接口

* 创建人：anan

* 创建时间：2012-12-21 下午10:58:32

* 修改人：anan

* 修改时间：2012-12-21 下午10:58:32

* 修改备注：

* @version

* */

public
interface UserService
{

/**

* 判断用户是否存在

* @param userName

* @return user

* @

* */

public
boolean isExitUser(String
userName) ;

/**

* 判断用户是否存在

* @param userName passWord

* @return user

* @

* */

public
boolean isExitByNameAndPass(User
user) ;

/**

* 保存用户

* @param user

* @return boolean

* @

* */

public
void save(User user)
;

/**

* 查询所有用户

* @param

* @return List<User>

* @

* */

public
List<User> getUsers() ;

/**

* 删除用户

* @param userId

* @return

* @

* */

public
void del(int
userId) ;

/**

* 修改用户

* @param user

* @return

* @

* */

public
void update(User
user) ;

/**

* 根据id获得user

* @param userId

* @return user

* @

* */

public
User getUserById(int
userId) ;

}

这个只是一个接口，定义我们接下来需要的方法。下面是具体的实现类UserServiceImpl.java

[java]
view plaincopy

package
com.ssh.user.service.Impl;

import
java.util.List;

import
javax.annotation.Resource;

import
org.springframework.stereotype.Service;

import
org.springframework.transaction.annotation.Propagation;

import
org.springframework.transaction.annotation.Transactional;

import
com.ssh.user.dao.UserDao;

import
com.ssh.user.model.User;

import
com.ssh.user.service.UserService;

/**

* 类名称：UserServiceImpl

* 类描述：用户信息操作业务逻辑接口实现

* 创建人：anan

* 创建时间：2012-12-21 下午11:08:18

* 修改人：anan

* 修改时间：2012-12-21 下午11:08:18

* 修改备注：

* @version

* */

@Service

public
class UserServiceImpl
implements UserService
{

@Resource

private
UserDao userDao;

public
boolean isExitUser(String
userName) {

return
userDao.isExitByName(userName);

}

public
void save(User user)
{

userDao.addUser(user);

}

public
List<User> getUsers() {

List<User> users = userDao.selectUser();

return
users;

}

public
void del(int
userId) {

userDao.delUser(userId);

}

public
void update(User
user) {

userDao.updateUser(user);

}

public
User getUserById(int
userId) {

return
userDao.getUserByUserId(userId);

}

public
boolean isExitByNameAndPass(User
user) {

return
userDao.isExitByNameAndPass(user);

}

}

业务逻辑在这里包括了判断用户是否存在，保存用户信息，获取用户信息，删除用户，更新用户信息等

通过上面两个类业务逻辑层也就完成了，接下来写视图控制器，这里只是写了一个简单的登录控制器LoginAction.java

[java]
view plaincopy

package
com.ssh.user.action;

import
javax.annotation.Resource;

import
org.apache.struts2.convention.annotation.Action;

import
org.apache.struts2.convention.annotation.Result;

import
com.opensymphony.xwork2.ActionSupport;

import
com.ssh.user.dao.UserDao;

import
com.ssh.user.model.User;

/**

* 类名称：LoginAction

* 类描述：用户控制器的实现

* 创建人：anan

* 创建时间：2012-12-21 下午11:17:36

* 修改人：anan

* 修改时间：2012-12-21 下午11:17:36

* 修改备注：

* @version

* */

@Action(value
= "loginAction", results = {

@Result(name
= "loginSuccess", location =
"/loginSuss.jsp"),

@Result(name
= "loginFailer", location =
"/loginFailer.jsp") })

public
class LoginAction
extends ActionSupport
{

private
static
final
long serialVersionUID
= -2266695172069461659L;

@Resource

private
UserDao userDao;

private
User user;

public
User getUser() {

return
user;

}

public
void setUser(User
user) {

this.user
= user;

}

public
String login(){

boolean
flag = userDao.isExitByNameAndPass(user);

if(flag){

return
"loginSuccess";

}

return
"loginFailer";

}

}

这个就是控制层。

再写几个jsp文件来测试一下



内容如下：

index.jsp

[html]
view plaincopy

<%@
page language="java"
import="java.util.*"
pageEncoding="UTF-8"%>

<%@taglib
prefix="s"
uri="/struts-tags"%>

<%

String

path =
request.getContextPath();

String

basePath =
request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";

%>

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">

<html>

<head>

<base
href="<%=basePath%>">

<title>My
JSP 'index.jsp' starting page</title>

<meta
http-equiv="pragma"
content="no-cache">

<meta
http-equiv="cache-control"
content="no-cache">

<meta
http-equiv="expires"
content="0">

<meta
http-equiv="keywords"
content="keyword1,keyword2,keyword3">

<meta
http-equiv="description"
content="This
is my page">

<!--

<link rel="stylesheet" type="text/css"
href="styles.css">

-->

</head>

<body>

<s:form
action="loginAction!login">

<s:textfield
name="user.userName"
label="userName"></s:textfield>

<s:textfield
name="user.passWord"
label="passWord"></s:textfield>

<s:submit
value="login"></s:submit>

</s:form>

</body>

</html>

loginFailer.jsp

[html]
view plaincopy

<%@
page language="java"
import="java.util.*"
pageEncoding="UTF-8"%>

<%

String

path =
request.getContextPath();

String

basePath =
request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";

%>

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">

<html>

<head>

<base
href="<%=basePath%>">

<title>My
JSP 'loginFailer.jsp' starting page</title>

<meta
http-equiv="pragma"
content="no-cache">

<meta
http-equiv="cache-control"
content="no-cache">

<meta
http-equiv="expires"
content="0">

<meta
http-equiv="keywords"
content="keyword1,keyword2,keyword3">

<meta
http-equiv="description"
content="This
is my page">

<!--

<link rel="stylesheet" type="text/css"
href="styles.css">

-->

</head>

<body>

登录失败

</body>

</html>

loginSuss.jsp

[html]
view plaincopy

<%@
page language="java"
import="java.util.*"
pageEncoding="utf-8"%>

<%

String

path =
request.getContextPath();

String

basePath =
request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";

%>

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">

<html>

<head>

<base
href="<%=basePath%>">

<title>My
JSP 'loginSuss.jsp' starting page</title>

<meta
http-equiv="pragma"
content="no-cache">

<meta
http-equiv="cache-control"
content="no-cache">

<meta
http-equiv="expires"
content="0">

<meta
http-equiv="keywords"
content="keyword1,keyword2,keyword3">

<meta
http-equiv="description"
content="This
is my page">

<!--

<link rel="stylesheet" type="text/css"
href="styles.css">

-->

</head>

<body>

登录成功

<br>

</body>

</html>

启动tomcat我们可以看到数据库自动生成一个user表。我们添加一条记录为下面测试



接下来打开浏览器，输入http://localhost:8080/ssh/可以看到下图页面就可以测试了



觉得使用了ssh结构之后整个工程的层次感就那样出来了。搞鼓一下收获还是蛮大的，基于注解的ssh是比xml方便很多，看大家喜欢吧

源码下地址

http://download.csdn.net/detail/yunji3344/4915649