【化学药品管理平台——Struts2+Spring+Hibernate实现 0201】SSH框架搭建

上一个系列，我们采用Servlet+Jsp开发了Cupboard化学药物管理平台。本次，我们将以传统的SSH框架（struts2+spring+hibernate）来重新开发这个Web应用。

两种架构都是MVC设计模式，并且分层开发。上一个系列我们按照控制层、业务层、持久层的顺序来讲解，本次，我们将按照持久层、业务层、控制层，即相反的顺序来讲解。

文件结构和之前的基本一致，依然是分层开发，只是具体的实现方法变了。下面从框架和框架之间的整合开始讲解。

Hibernate

首先是hibernate框架。

Hibernate是一个开放源代码的对象关系映射框架，它对JDBC进行了非常轻量级的对象封装，它将POJO与数据库表建立映射关系，是一个全自动的orm框架，hibernate可以自动生成SQL语句，自动执行，使得Java程序员可以随心所欲的使用对象编程思维来操纵数据库。

hibernate需要的jar包

hibernate核心文件hibernate.cfg.xml

导入hibernate相关jar包之后，我们开始配置hibernate核心文件hibernate.cfg.xml。

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC
	"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
	"http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
	
<hibernate-configuration>
	
	<session-factory>
		<!-- 必须要配置的参数有5个，4大参数，数据库的方言 -->
		<property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
		<property name="hibernate.connection.url">jdbc:mysql:///cupboard</property>
		<property name="hibernate.connection.username">root</property>
		<property name="hibernate.connection.password">root</property>
		<!-- 数据库的方言 -->
		<property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
		
		<!-- 可选配置 -->
		<!-- 显示SQL语句，在控制台显示 -->
		<property name="hibernate.show_sql">true</property>
		<!-- 格式化SQL语句 -->
		<property name="hibernate.format_sql">true</property>
			<!-- 生成数据库的表结构 
				update：如果没有表结构，创建表结构。如果存在，不会创建，添加数据
		-->
		<property name="hibernate.hbm2ddl.auto">update</property>
		<!-- 获取线程中的session需要在此配置 -->
		<property name="hibernate.current_session_context_class">thread</property>
		
		<!-- 配置C3P0的连接池 -->
		<property name="connection.provider_class">org.hibernate.connection.C3P0ConnectionProvider</property>
		
		<!-- 映射配置文件，需要引入映射的配置文件 -->
		<mapping resource="com/rclv/domain/Agents.hbm.xml"/>
		<mapping resource="com/rclv/domain/User.hbm.xml"/>
	</session-factory>
	
</hibernate-configuration>

首先，有五个必须配置的参数，分别是：

hibernate.connection.driver_class：数据库驱动

hibernate.connection.url：连接数据库URL

hibernate.connection.username：数据库用户名

hibernate.connection.password：数据库密码

hibernate.dialect：以及数据库方言

可选配置有：

hibernate.show_sql：在控制台显示SQL语句

hibernate.format_sql：格式化SQL语句

hibernate.hbm2ddl.auto：自动生成数据库的表结构（如果没有当前表结构）

其他配置：

connection.provider_class：配置数据库连接池

<mapping resource="/XXX.hbm.xml"/>：映射配置文件，填写src之后的全路径

Hibernate映射文件Entity.hbm.xml

接下来需要配置映射文件Entity.hbm.xml。

上一个系列中介绍过，user表和agents表是一对多的关系，这在各自的映射文件中同样需要进行相关的配置。我们先来看User的映射文件配置。

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC 
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
    
<hibernate-mapping>
	
	<class name="com.rclv.domain.User" table="user">
		<id name="uid" column="uid">
			<generator class="assigned"/>
		</id>
		
		<property name="uname" column="uname"/>
		<property name="ugrade" column="ugrade"/>
		<property name="upassword" column="upassword"/>
		
		<set name="agents">
			
			<key column="uid"></key>
			<one-to-many class="com.rclv.domain.Agents"/>
		</set>
		
	</class>
	
</hibernate-mapping>

class标签：

name：类的类全名

table：表名（类名与表名一致，则table属性可以省略）

id标签（配置主键）：

name：主键对应的类属性名

column：表中对应字段名（若类中属性名与表中的字段名一致，则column可以省略）

generator标签：

class：主键生成策略。assigned表示hibernate不负责主键生成，由外部程序负责。

property标签：

name：类中属性名

column：表中对应字段名（若类中属性名与表中的字段名一致，则column可以省略）

set标签（集合映射）：

name：类中set集合的属性

key标签：

column：多方表的外键字段

one-to-many标签（表示一对多的关联关系）：

class：关联多方类的类全名

Agents的映射文件配置

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC 
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
    
<hibernate-mapping>
	
	<class name="com.rclv.domain.Agents" table="agents">
		<id name="aid" column="aid">
			<generator class="native"/>
		</id>
		
		<property name="aname" column="aname"/>
		<property name="aimg" column="aimg"/>
		<property name="aboard" column="aboard"/>
		
		<property name="ano" column="aNo"/>
		<property name="acas" column="aCAS"/>
		<property name="aspec" column="aspec"/>
		
		<property name="count" column="count"/>
		<property name="aunit" column="aunit"/>
		<property name="astore" column="astore"/>
		
		<property name="asup" column="asup"/>
		<property name="adate" column="adate"/>
		
		<many-to-one name="user" class="com.rclv.domain.User" column="uid" lazy="false" cascade="save-update"/>

	</class>
	
</hibernate-mapping>

class、id、property标签属性同上。

many-to-one标签：

name：类中属性名

class：关联一方类的类全名

column：外键字段

lazy：设置延迟加载

cascade：设置级联策略

JUnit测试

我们使用JUnit进行测试。

	/*
	 * hibernate第一次测试
	 */
	@Test
	public void hibernateRegistTest() {
		// 1.先加载配置文件,默认加载src目录下hibernate.cfg.xml的配置文件
		Configuration configure = new Configuration().configure();
		// 2.创建SessionFactory对象
		SessionFactory sessionFactory = configure.buildSessionFactory();
		// 3.创建session对象
		Session session = sessionFactory.openSession();
		// 4.开启事务
		Transaction tr = session.beginTransaction();
		
		// 5.编写添加数据代码。新建user对象，处于瞬时态。
		User user = new User();		
		user.setUid(UUIDUtils.getId());
		user.setUname("YangfH");
		user.setUpassword(MD5Utils.md5("y23456"));
		user.setUgrade("2018");
		
		// 6.保存数据，操作对象就相当于操作数据库的表结构。此时user处于持久态。
		session.save(user);
		
		// 7.提交事务
		tr.commit();
		// 8.释放资源
		session.close();
	}

1.先加载配置文件,默认加载src目录下hibernate.cfg.xml的配置文件

2.创建SessionFactory对象

3.创建session对象

4.开启事务

5.编写添加数据代码。新建user对象，处于瞬时态。

6.保存数据，操作对象就相当于操作数据库的表结构。此时user处于持久态。 7.提交事务

8.释放资源

查看数据库，可以看到新添加的user数据。

HibernateUtils工具类

为了方便获取session，我们可以从上面的代码中抽取一个HibernateUtils工具类。

package com.rclv.utils;

/**
 * Hibernate框架的工具类
 */
public class HibernateUtils {
	
	private static final Configuration CONFIG;
	private static final SessionFactory FACTORY;
	
	// 编写静态代码块
	static{
		// 加载XML的配置文件
		CONFIG = new Configuration().configure();
		// 构造工厂
		FACTORY = CONFIG.buildSessionFactory();
	}
	
	/**
	 * 从工厂中获取Session对象
	 * @return
	 */
	public static Session getSession(){
		return FACTORY.openSession();
	}
	
	/**
	 * // 从ThreadLocal类中获取到session的对象
	 * @return
	 */
	public static Session getCurrentSession(){
		return FACTORY.getCurrentSession();
	}
	
	public static void main(String[] args) {
		// 调用获取session的方法
		getSession();
	}
	
}

我们将Configuration和SessionFactory类对象设为类变量（静态变量），并用final关键字修饰，然后再静态代码块中对其进行初始化。

Session getSession()方法返回FACTORY.openSession()，表示从SessionFactory工厂中获取一个Session对象。

Session getCurrentSession()方法返回FACTORY.getCurrentSession()，表示从当前线程中获取一个Session对象。若当前线程中没有Session，则新建一个Session对象。若要使用getCurrentSession()方法，需要在hibernate.cfg.xml中配置：

<property name="hibernate.current_session_context_class">thread</property>。

优化testUserLogin类的代码如下。

/*
 * 抽取hibernate工具类后的测试
 */
@Test
public void hibernateRegistTest2() {
	// 1.从HibernateUtils工具类中获取session。
	Session session = HibernateUtils.getSession(); 
	// 2.开启事务
	Transaction tr = session.beginTransaction();
	
	// 3.编写添加数据代码。新建user对象，处于瞬时态。
	User user = new User();		
	user.setUid(UUIDUtils.getId());
	user.setUname("YangfH");
	user.setUpassword(MD5Utils.md5("y23456"));
	user.setUgrade("2018");
	
	// 4.保存数据，操作对象就相当于操作数据库的表结构。此时user处于持久态。
	session.save(user);
	
	// 5.提交事务
	tr.commit();
	// 6.释放资源
	session.close();
}

分层开发

现在，我们可以把业务和数据查询分层开发。将事物的开启、提交和回滚都写在service层，将session对数据库的操作写在dao层。

public class SpringTest {
	/*
	 * 分层开发测试类传入User实例
	 */
	@Test
	public void currentSessionTest() {
		
		// 1.创建要添加的User实例
		User user = new User();
		user.setUid(UUIDUtils.getId());
		user.setUname("Spring");
		user.setUpassword(MD5Utils.md5("s23456"));
		user.setUgrade("2018");
		// 2.BeanFactory获取UserService实现类，并调用us.registTest(user)方法
		UserService us = (UserService) BeanFactory.getBean("UserService");
		us.registAtService(user);
		
	}

package com.rclv.service.impl;

@Transactional
public class UserServiceImpl implements UserService {
	/*
	 * 分层开发业务层
	 */
	public void registAtService(User user) {
		// 1。新建Session和Transaction类对象
		Session session = null;
		Transaction tr = null;
		try {
			// 2.从线程中获取session，并开始事务
			session = HibernateUtils.getCurrentSession();
			tr = session.beginTransaction();
			
			// 3.BeanFactory获取UserDao实现类，并调用ud.regist(user)方法
			UserDao ud = (UserDao) BeanFactory.getBean("UserDao");
			ud.registAtDao(user);
			
			// 4.提交事务
			tr.commit();
		} catch (Exception e) {
			// 5.事务回滚
			tr.rollback();
			e.printStackTrace();
		} finally {
			// 6.线程结束session会自动关闭
		}
		
	}

package com.rclv.dao.impl;

public class UserDaoImpl extends HibernateDaoSupport implements UserDao {
	/*
	 * 分层开发持久层
	 */
	@Override
	public void registAtDao(User user){
		Session session = HibernateUtils.getCurrentSession();
		session.save(user);
		/*this.getHibernateTemplate().save(user);*/
	}

首先写一个sessionTest()的测试类。

创建要添加的User实例。
用上一个系列中的BeanFactory工具类获取UserService的实现类，并调用其方法进入service层。

service层。

新建Session类和Transaction类对象。
在try语句块中，从线程中获取session，并开启事务。
用上一个系列中的BeanFactory工具类获取UserDao的实现类，并调用其方法进入dao层。
提交事务。
出现异常在catch语句块中对事务进行回滚。
正常应该在finally语句块中关闭session资源，但是通过线程获取的session会在线程结束后自动关闭。

dao层。

从当前线程中获取session。这个session和service层中的session是一个session。
执行保存操作，完成数据添加。

Spring

Spring是一个开放源代码的设计层面框架，它解决的是业务逻辑层和其他各层的松耦合问题，因此它将面向接口的编程思想贯穿整个系统应用。

Spring需要的jar包

核心配置文件applicationContext.xml

上一个系列中，我们有一个BeanFactory工具类，来获取实现类，这是一种工厂模式。现在，我们将接口实现类的创建交给Spring框架来管理，也就是由Spring来创建。将对象的创建权反转给Spring，就实现了控制反转（IoC）。

<?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">
	
	<bean id="userService" class="com.rclv.service.impl.UserServiceImpl"/>		
	
</beans>

把实现类的创建交给Spring框架来管理，需在Spring的配置文件applicationContext.xml中配置相应的<bean>标签。

bean标签：

id：作为Bean的名称

class：Bean对象的全路径

scope：表示Bean的作用范围

测试程序

编写测试程序，采用工厂方式获取Spring创建的UserService接口实现类。

/*
 * Spring创建实现类
 */
@Test
public void springRegistTest() {
	// 1.使用Spring的工厂类加载配置文件，ApplicationContext接口是BeanFactory的子接口
	ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
	// 2.通过工厂获取UserService的实现类
	UserService us = (UserService) applicationContext.getBean("userService");
	// 3.创建要添加的User实例
	User user = new User();
	user.setUid(UUIDUtils.getId());
	user.setUname("Spring");
	user.setUpassword(MD5Utils.md5("s23456"));
	user.setUgrade("2018");
	// 4.调用UserService.registTest(User user)方法
	us.registAtService(user);
	/*userService.registTest2();*/
}

通过ApplicationContext的实现类ClassPathXmlApplicationContext来加载Spring配置文件。
通过Spring工厂获取UserService的实现类。
创建要添加的User类实例。
调用UserService.registAtService(User user)方法。该方法还是前面service层中的方法，运行测试类可以完成数据添加操作。

依赖注入（配置）

依赖注入就是指，在Spring框架负责创建Bean对象时，动态的将依赖对象注入到Bean组件中。

例如：如果UserService的实现类中有一个属性，那么使用Spring框架的IoC功能时，可以通过依赖注入把该属性的值传入进来。这样一来，在该实现类中，就可以很方便地获取该属性。

在applicationContext.xml中的配置如下：

    <bean id="userService" class="com.rclv.service.impl.UserServiceImpl">
	    <property name="uname" value="Yangf"></property>
	    <property name="userDao" ref="userDao"/>
    </bean>

property标签：

name：需要注入的属性名

value：普通属性值

ref：查找当前配置文件里的bean，表示注入的是其他类。

依赖注入的方式

常用的注入方式主要有两种，构造器注入和set方法注入。我们这里需要用到set方法注入，所以只介绍set方式的依赖注入。

public class UserServiceImpl implements UserService {
	// 依赖注入
	private UserDao userDao;
	public void setUserDao(UserDao userDao) {
		this.userDao = userDao;
	}

	<bean id="userService" class="com.rclv.service.impl.UserServiceImpl">
		<property name="userDao" ref="userDao"/>
	</bean>
	
	<bean id="userDao" class="com.rclv.dao.impl.UserDaoImpl"/>

注入方式：

1. 在需要注入的实现类UserServiceImpl中，聚合一个UserDao类，然后提供对应的set方法。

2. 在配置文件中，分别配置UserServiceImpl和UserDaoImpl两个实现类的bean标签，然后在用property标签的ref属性，将UserDaoImpl注入到UserServiceImpl的bean组件中。

这样一来，程序运行时，我们就可以在UserService中直接获取Spring帮我们注入的UserDao的实现对象了。

前面UserServiceImpl.registAtService()方法中获取UserDao实现对象的方法就可以换成Spring依赖注入的方式了。

/*
 * 测试类中Spring创建实现类
 */
@Test
public void springRegistTest2() {
	// 1.使用Spring的工厂类加载配置文件，ApplicationContext接口是BeanFactory的子接口
	ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
	// 2.通过工厂获取UserService的实现类
	UserService us = (UserService) applicationContext.getBean("userService");
	// 3.创建要添加的User实例
	User user = new User();
	user.setUid(UUIDUtils.getId());
	user.setUname("Spring");
	user.setUpassword(MD5Utils.md5("s23456"));
	user.setUgrade("2018");
	// 4.调用UserService.registTest2(User user)方法
	us.registAtService2(user);
}

private UserDao userDao;
public void setUserDao(UserDao userDao) {
	this.userDao = userDao;
}

/*
 * 业务层Spring依赖注入
 */
public void registAtService2(User user) {
	// 1。新建Session和Transaction类对象
	Session session = null;
	Transaction tr = null;
	try {
		// 2.从线程中获取session，并开始事务
		session = HibernateUtils.getCurrentSession();
		tr = session.beginTransaction();
		
		// 3.获取注入的UserDao实现类，并调用userDao.regist(user)方法
		userDao.registAtDao(user);
		
		// 4.提交事务
		tr.commit();
	} catch (Exception e) {
		// 5.事务回滚
		tr.rollback();
		e.printStackTrace();
	} finally {
		// 6.线程结束session会自动关闭
	}
	
}

/*
 * 分层开发持久层
 */
@Override
public void registAtDao(User user){
	Session session = HibernateUtils.getCurrentSession();
	session.save(user);
	/*this.getHibernateTemplate().save(user);*/
}

在测试方法中调用UserService.registTest2(User user)进入service层，在service层中，通过set方法注入了UserDao类对象。现在可以直接获取UserDao的实现类，并调用其方法，而不再通过BeanFactory工厂模式获取了。

Struts2

Struts2是一个基于MVC设计模式的Web应用框架，它本质上相当于一个servlet，在MVC设计模式中，Struts2作为控制器(Controller)来建立模型与视图的数据交互。Struts 2以WebWork为核心，采用拦截器的机制来处理用户的请求，这样的设计也使得业务逻辑控制器能够与ServletAPI完全脱离开，所以Struts 2可以理解为WebWork的更新产品。

Struts2需要的jar包

配置Struts2核心控制器

Struts2的前端核心控制器，也就是Struts2的核心控制器，是一个过滤器，需要在web.xml中进行配置。

前端控制器的类全名：

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

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" id="WebApp_ID" version="2.5">
  <display-name>cupboard_ssh2</display-name>
	
	<!-- 配置Struts2框架的核心的过滤器 -->
	<filter>
		<filter-name>struts2</filter-name>
		<filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>
	</filter>
	<filter-mapping>
		<filter-name>struts2</filter-name>
		<url-pattern>/*</url-pattern>
	</filter-mapping>
	
</web-app>

Action类

Action类是动作类，是Struts2处理请求，封装数据，响应页面的核心控制类。用户的每次请求，都会转到一个相应的Action类里面。在本次的SSH框架开发中，Action类是用来替代Servlet的，是用来处理用户请求的对象。

public class UserAction {
	
	// 1.访问路径：http://localhost/cup_ssh2/user_registUI.action
	public String registUI() {
		// 2.返回值代表跳转到register.jsp页面
		return "register";
	}
	

	// BeanFactory方式获取UserService实现类，访问路径：http://localhost/cup_ssh2/user_registTest.action
	public String registTest(){
		// 1.ModelDriven将获取到的前台数据传给User实体类对象，然后再设置user的uid变量，并加密upassword变量
		user.setUid(UUIDUtils.getId());
		user.setUpassword(MD5Utils.md5(user.getUpassword()));
		
		// 2.通过BeanFactory工厂类获取UserService实现类，并调用us.registTest(user)方法
		UserService us = (UserService) BeanFactory.getBean("UserService");
		us.registTest(user);
		
		// 3.设置request域属性
		request.setAttribute("msg", "注册成功");
		
		// 4.跳转到msg.jsp页面
		return "msg";
	}

在UserAction中，我们写了两个方法，registUI()和registTest()，用来完成跳转到注册页面和提交注册表单的功能。

registUI()方法中，只有一个return语句，返回的字符串代表了处理完请求之后将要跳转到的页面。对于Action的请求和页面响应都在Struts2的核心配置文件中进行配置，我们先看其配置文件。

struts.xml配置文件

在Struts2默认配置文件中，struts.xml是需要开发者来自己定义的。struts.xml配置文件的主要作用是配置请求和Action之间的对应关系，并配置逻辑试图名和物理视图资源之间的对应关系。

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE struts PUBLIC
	"-//Apache Software Foundation//DTD Struts Configuration 2.3//EN"
	"http://struts.apache.org/dtds/struts-2.3.dtd">
	
<struts>

	<!-- 配置包结构 -->
    <package name="cupboard" extends="struts-default" namespace="/">
    	
    	<action name="user_registUI" class="com.rclv.web.action.UserAction" method="registUI">
    		<result name="register">/jsp/register.jsp</result>
    	</action>
    	
    	<action name="user_strutsRegistTest" class="com.rclv.web.action.UserAction" method="strutsRegistTest">
    		<result name="msg">/jsp/msg.jsp</result>	
    	</action>
    	
    </package>
    
</struts>

package标签：

name：包名，可任意取值，但须唯一

namespace：定义包的命名空间，与<action>标签中的name属性共同决定访问路径，namespace="/"表示根名称空间

extends：一般都继承struts-default，因为struts2的主要功能都定义在这个包中

action标签：

name：和<package>标签中的namespace属性共同决定访问路径

class：配置Action类的全路径

method：Action类中执行的方法，如果未指定，默认值执行execute()方法

result标签：

name：结果页面逻辑视图名称，对应Action类中方法的返回值。

result标签内为Action执行完成后所要跳转的视图资源路径。

type：结果类型，默认为请求转发。

配置完成后，测试UserAction类中的registUI()方法。

<c:if test="${empty user }">
    <li style="position: relative; left:68%"><a href="${pageContext.request.contextPath }/user_loginUI.action">登录</a></li>
    <li style="position: relative; left:68%"><a href="${pageContext.request.contextPath }/user_registUI.action">注册</a></li>
</c:if>

从前台页面开始访问注册请求，由于namespace=”/”，则访问路径为项目路径+”/action标签的name属性值”+”.action”。执行完UserAction类中的registUI()方法，就跳转到register.jsp注册页面。

<form id="formId" action="${pageContext.request.contextPath }/user_strutsRegistTest.action" method="post">
	<table>
		<tr>
			<th>用户名：</th>
			<th><input type="text" name="uname"/></th>
		</tr>
		<tr>
			<th>密码：</th>
			<th><input type="password" name="upassword"/></th>
		</tr>
		<tr>
			<th>入学年份：</th>
			<th><input type="text" name="ugrade"/></th>
		</tr>
		<tr>
			<th></th>
			<th align="right"><input type="submit" value="提交"/></th>
		</tr>
	</table>
</form>

转到register.jsp页面后，填写注册表单，提交表单，请求到UserAction中的strutsRegistTest()方法。

对于strutsRegistTest()方法，我们先对UserAction类实现ServletRequestAware, ModelDriven<T>这两个struts2提供的接口，并实现各自对应的方法。

实现ServletRequestAware接口后，程序会自动创建HttpServletRequest对象，我们可以直接拿来使用。

实现ModelDriven<User>模型驱动接口后，前台传来的数据会直接赋给User实体类对象。所以，需要注意的是，ModelDriven<T>中的类T必须实例化。

public class UserAction extends ActionSupport implements ServletRequestAware, ModelDriven<User> {
	
	HttpServletRequest request;  
	public void setServletRequest(HttpServletRequest request) {  
	    this.request = request;  
	}
	
	// User对象必须实例化
	private User user = new User();
	public User getModel() {
		return user;
	}
	
	//BeanFactory方式获取UserService实现类，访问路径：http://localhost/cup_ssh2/user_strutsRegistTest.action
	public String strutsRegistTest(){
		// 1.ModelDriven将获取到的前台数据传给User实体类对象，然后再设置user的uid变量，并加密upassword变量
		user.setUid(UUIDUtils.getId());
		user.setUpassword(MD5Utils.md5(user.getUpassword()));
		
		// 2.通过BeanFactory工厂类获取UserService实现类，并调用us.registTest(user)方法
		UserService us = (UserService) BeanFactory.getBean("UserService");
		us.registTest(user);
		
		// 3.设置request域属性
		request.setAttribute("msg", "注册成功");
		
		// 4.跳转到msg.jsp页面
		return "msg";
	}

1. ModelDriven将获取到的前台数据传给User实体类对象，然后再设置user的uid变量，并加密upassword变量。

2. 通过BeanFactory工厂类获取UserService实现类，并调用us.registAtService(user)方法。

3. 设置request域属性。

4. 注册成功，跳转到msg.jsp页面。

至此，我们介绍完了三大框架的配置，并对各个框架的功能进行了测试。

下一篇我们需要将三个框架整合在一起进行开发。

posted @ 2018-07-20 12:27 XD_Yangf 阅读(8) 评论(0) 编辑收藏举报

刷新页面返回顶部

【化学药品管理平台——Struts2+Spring+Hibernate实现 0201】SSH框架搭建

公告