SSH整合
Spring和Struct2整合就是将Action对象交给Spring容器负责创建。Spring和Hibernate整合就是将SessionFactory交给Spring来负责维护。
同时Spring还可以负责session维护以及AOP事务管理。
首先创建Maven项目，作如下勾选：
创建完成后只是一个空项目，接下来创建相应的目录结构即可。
然后创建相应的数据库：
use ssh_db;
CREATE TABLE `user`
(
`user_id` bigint(20) unsigned NOT NULL auto_increment COMMENT 'ID',
`user_name` varchar(40) character set utf8 NOT NULL COMMENT '用户名',
`user_password` varchar(40) collate utf8_unicode_ci NOT NULL COMMENT '密码',
`nick_name` varchar(40) character set utf8 COMMENT '昵称',
PRIMARY KEY (`user_id`)
) ENGINE = InnoDB
AUTO_INCREMENT = 1
DEFAULT CHARSET = utf8
COLLATE = utf8_unicode_ci COMMENT ='用户信息表';
框架配置
依赖文件
在pom.xml中添加如下依赖：
<dependencies>
<!-- spring-context -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.1.0.RELEASE</version>
</dependency>
<!-- spring-web -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-web</artifactId>
<version>5.1.0.RELEASE</version>
</dependency>
<!--spring-jdbc -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>5.1.0.RELEASE</version>
</dependency>
<!-- spring-orm -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-orm</artifactId>
<version>5.1.0.RELEASE</version>
</dependency>
<!-- aop面向切面依赖的jar包 -->
<!-- aspectjrt -->
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjrt</artifactId>
<version>1.9.1</version>
</dependency>
<!-- aspectjweaver -->
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>1.9.1</version>
</dependency>
<!-- hibernate依赖 -->
<!-- hibernate核心依赖 -->
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-core</artifactId>
<version>5.2.17.Final</version>
</dependency>
<!-- mysql数据库驱动依赖 -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.47</version>
</dependency>
<!-- c3p0连接池 -->
<dependency>
<groupId>com.mchange</groupId>
<artifactId>c3p0</artifactId>
<version>0.9.5.2</version>
</dependency>
<!-- struts2依赖 -->
<!-- struts2 -->
<dependency>
<groupId>org.apache.struts</groupId>
<artifactId>struts2-core</artifactId>
<version>2.3.35</version>
</dependency>
<!-- struts2-spring-plugin整合spring和struts2 -->
<dependency>
<groupId>org.apache.struts</groupId>
<artifactId>struts2-spring-plugin</artifactId>
<version>2.3.35</version>
</dependency>
<!-- servlet api -->
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>javax.servlet-api</artifactId>
<version>3.1.0</version>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>javax.servlet.jsp</groupId>
<artifactId>javax.servlet.jsp-api</artifactId>
<version>2.3.1</version>
<scope>provided</scope>
</dependency>
<!-- lombok -->
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>1.18.0</version>
<scope>provided</scope>
</dependency>
<!-- jstl -->
<dependency>
<groupId>jstl</groupId>
<artifactId>jstl</artifactId>
<version>1.2</version>
</dependency>
<dependency>
<groupId>taglibs</groupId>
<artifactId>standard</artifactId>
<version>1.1.2</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-test</artifactId>
<version>5.3.8</version>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
<scope>compile</scope>
</dependency>
</dependencies>
Spring配置
1、创建一个Action，这里取名为UserAction
public class UserAction extends ActionSupport{
private UserService userService;
public void setUserService(UserService userService) {
this.userService = userService;
}
public String login() throws Exception {
System.out.println(userService);
return super.execute();
}
}
2、创建一个Service层的类，其中包括接口UserService和UserServiceImp类
// UserService
public interface UserService {
User getUserByCodePassword(User user);
}
// UserServiceImp
public class UserServiceImp implements UserService{
@Override
public User getUserByCodePassword(User user) {
System.out.println("111111111111");
return null;
}
}
3、在项目的resources下创建applicationContext.xml配置文件，然后将Action和Service托管给Spring容器。
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd">
<!--Action配置，Action对象作用范围一定是多例的，这样才符合Struct2架构-->
<bean name="userAction" class="com.legend.ssh.action.UserAction" scope="prototype">
<property name="userService" ref="userService"></property>
</bean>
<!--Service配置-->
<bean name="userService" class="com.legend.ssh.service.imp.UserServiceImp"></bean>
</beans>
3、在web.xml中配置Spring随项目启动而启动
<?xml version="1.0" encoding="ISO-8859-1"?>
<web-app>
<display-name>Archetype Created Web Application</display-name>
<!--让Spring随项目启动而启动的监听器-->
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
<!--配置Spring配置文件参数-->
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:applicationContext.xml</param-value>
</context-param>
</web-app>
其中使用到的User.java类在domain包下：
public class User {
private Long user_id;
private String user_name;
private String user_password;
private String nick_name;
...Get & Set ..
}
Struct2配置
1、在resource下创建Struct2的配置文件，名为struts.xml的的配置文件，并配置Struct2的主配置文件，和Action建立关联。
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE struts PUBLIC
"-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
"http://struts.apache.org/dtds/struts-2.0.dtd">
<struts>
<package name="ssh" namespace="/" extends="struts-default">
<action name="UserAction_*" class="com.legend.ssh.action.UserAction" method="{1}">
<result name="success">/success.jsp</result>
</action>
</package>
</struts>
2、在web.xml中配置Struct2的核心过滤器
<!--Struct2核心监听器注册-->
<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>
Hibernate配置
1、添加实体配置文件User.hbm.xml
<?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 package="com.legend.ssh.domain" >
<class name="User" table="user">
<id name="user_id" >
<generator class="native"></generator>
</id>
<property name="user_name"></property>
<property name="user_password"></property>
<property name="nick_name"></property>
</class>
</hibernate-mapping>
2、在resource下创建主配置文件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>
<!-- 数据库驱动 -->
<property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
<!-- 数据库url -->
<property name="hibernate.connection.url">jdbc:mysql:///ssh_db</property>
<!-- 数据库连接用户名 -->
<property name="hibernate.connection.username">root</property>
<!-- 数据库连接密码 -->
<property name="hibernate.connection.password">123456</property>
<!-- 数据库方言 注意: MYSQL在选择方言时,请选择最短的方言.-->
<property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
<!-- 将hibernate生成的sql语句打印到控制台 -->
<property name="hibernate.show_sql">true</property>
<!-- 将hibernate生成的sql语句格式化(语法缩进) -->
<property name="hibernate.format_sql">true</property>
<!-- 自动导出表结构. 自动建表-->
<property name="hibernate.hbm2ddl.auto">update</property>
<!-- 引入实体配置文件 -->
<mapping resource="mapper/User.hbm.xml" />
</session-factory>
</hibernate-configuration>
框架整合
Spring整合Struct2
在structs标签下添加常量配置，将action的创建交给Spring容器管理，并且让Spring负责装配依赖属性，这里有两种方案：
方案一：class属性仍然配置action完整类名，Struct2仍然创建Action，其中Spring只负责组装Action中的依赖属性（不推荐）
<struts>
<!--将action的创建交给Spring容器-->
<constant name="struts.objectFactory" value="spring"></constant>
<!--依赖Spring负责装配Action依赖属性-->
<constant name="struts.objectFactory.spring.autoWire" value="name"></constant>
<package name="ssh" namespace="/" extends="struts-default">
<!--整合方案一
class属性上仍然配置action完整类名，Struct2仍然创建Action，但是由Spring负责组装Action中的依赖属性。
这种方式不推荐，最好让Spring来管理Action的生命周期-->
<action name="UserAction_*" class="com.legend.ssh.action.UserAction" method="{1}">
<result name="success">/success.jsp</result>
</action>
</package>
</struts>
方案二：class属性上填写Spring中action对象的BeanName，完全由Spring管理生命周期，包括Action的创建，需要手动组装依赖属性
<struts>
<!--将action的创建交给Spring容器-->
<constant name="struts.objectFactory" value="spring"></constant>
<!--依赖Spring负责装配Action依赖属性-->
<constant name="struts.objectFactory.spring.autoWire" value="name"></constant>
<package name="ssh" namespace="/" extends="struts-default">
<!--整合方案二
class属性上填写Spring中action对象的BeanName，完全由Spring管理生命周期，包括Action的创建
注意：需要手动组装依赖属性-->
<action name="UserAction_*" class="userAction" method="{1}">
<result name="success">/success.jsp</result>
</action>
</package>
</struts>
所以在Struct2中配置后，还需要在Spring中去配置该Action
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd">
<!--Action配置，Action对象作用范围一定是多例的，这样才符合Struct2架构-->
<bean name="userAction" class="com.legend.ssh.action.UserAction" scope="prototype">
<property name="userService" ref="userService"></property>
</bean>
<!--Service配置-->
<bean name="userService" class="com.legend.ssh.service.imp.UserServiceImp"></bean>
</beans>
Spring整合Hibernate
Spring整合Hibernate的原理就是将SessionFactory对象交给Spring容器进行管理，有三种方案：
方案一：仍然使用外部的hibernate.cfg.xml配置连接信息，然后在Spring配置applicatonContext.xml中做如下配置
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd">
<!--将SessionFactory配置到Spring容器中-->
<!--加载配置方案一：仍然使用外部的hibernate.cfg.xml配置连接信息-->
<bean name="sessionFactory" class="org.springframework.orm.hibernate5.LocalSessionFactoryBean">
<property name="configLocation" value="classpath:hibernate.cfg.xml.bat"></property>
</bean>
<!--Action配置，Action对象作用范围一定是多例的，这样才符合Struct2架构-->
<bean name="userAction" class="com.legend.ssh.action.UserAction" scope="prototype">
<property name="userService" ref="userService"></property>
</bean>
<!--Service配置-->
<bean name="userService" class="com.legend.ssh.service.imp.UserServiceImp"></bean>
</beans>
方案二：在Spring配置文件applicatonContext.xml中放置Hibernate配置连接信息
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd">
<!--将SessionFactory配置到Spring容器中-->
<!--加载配置方案二：在Spring配置中配置Hibernate配置连接信息-->
<bean name="sessionFactory" class="org.springframework.orm.hibernate5.LocalSessionFactoryBean">
<!--配置hibernate基本属性信息-->
<property name="hibernateProperties">
<props>
<!--必选配置-->
<prop key="hibernate.connection.driver_class">com.mysql.jdbc.Driver</prop>
<prop key="hibernate.connection.url">jdbc:mysql:///ssh_db</prop>
<prop key="hibernate.connection.username">root</prop>
<prop key="hibernate.connection.password">123456</prop>
<prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>
<!--可选配置-->
<prop key="hibernate.show_sql">true</prop>
<prop key="hibernate.format_sql">true</prop>
<prop key="hibernate.hbm2ddl.auto">update</prop>
</props>
</property>
<!--引入ORM元数据，指定ORM元数据所在包路径，Spring会自动读取包中的所有配置-->
<property name="mappingDirectoryLocations" value="classpath:com/legend/ssh/domain"></property>
</bean>
<!--Action配置，Action对象作用范围一定是多例的，这样才符合Struct2架构-->
<bean name="userAction" class="com.legend.ssh.action.UserAction" scope="prototype">
<property name="userService" ref="userService"></property>
</bean>
<!--Service配置-->
<bean name="userService" class="com.legend.ssh.service.imp.UserServiceImp"></bean>
</beans>
然后编写测试类进行测试，这里的SessionFactory是通过Spring管理获取的。
public class HibernateTest {
@Test
public void func() {
ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
StandardServiceRegistry serviceRegistry = new StandardServiceRegistryBuilder()
.configure().build();
SessionFactory factory = new MetadataSources( serviceRegistry ).buildMetadata().buildSessionFactory();
Session session = factory.openSession();
Transaction transaction = session.beginTransaction();
// 操作数据库
User user = new User();
user.setUser_name("神话");
user.setUser_password("123456");
user.setNick_name("神话");
session.save(user);
transaction.commit();
session.close();
}
}
- C3P0连接池
如果需要配置c3p0连接池的话，则可以通过连接的配置来配置连接信息，在resource下创建db.properties配置文件：
jdbc.jdbcUrl=jdbc:mysql:///ssh_db
jdbc.driverClass=com.mysql.jdbc.Driver
jdbc.username=root
jdbc.password=123456
然后在Spring的配置文件applicatonContext.xml中配置c3p0连接池信息，完整代码如下：
<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"
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">
<!-- 指定spring读取db.properties配置 -->
<context:property-placeholder location="classpath:db.properties" />
<!--将连接池放入Spring容器中管理-->
<bean name="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
<property name="jdbcUrl" value="${jdbc.jdbcUrl}"></property>
<property name="driverClass" value="${jdbc.driverClass}"></property>
<property name="user" value="${jdbc.username}"></property>
<property name="password" value="${jdbc.password}"></property>
</bean>
<!--将SessionFactory配置到Spring容器中-->
<!--加载配置方案二：在Spring配置中配置Hibernate配置连接信息-->
<bean name="sessionFactory" class="org.springframework.orm.hibernate5.LocalSessionFactoryBean">
<!--配置hibernate基本属性信息-->
<property name="hibernateProperties">
<props>
<!--必选配置-->
<prop key="hibernate.connection.driver_class">com.mysql.jdbc.Driver</prop>
<prop key="hibernate.connection.url">jdbc:mysql:///ssh_db</prop>
<prop key="hibernate.connection.username">root</prop>
<prop key="hibernate.connection.password">123456</prop>
<prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>
<!--可选配置-->
<prop key="hibernate.show_sql">true</prop>
<prop key="hibernate.format_sql">true</prop>
<prop key="hibernate.hbm2ddl.auto">update</prop>
</props>
</property>
<!--引入ORM元数据，指定ORM元数据所在包路径，Spring会自动读取包中的所有配置-->
<property name="mappingDirectoryLocations" value="classpath:com/legend/ssh/domain"></property>
</bean>
<!--Action配置，Action对象作用范围一定是多例的，这样才符合Struct2架构-->
<bean name="userAction" class="com.legend.ssh.action.UserAction" scope="prototype">
<property name="userService" ref="userService"></property>
</bean>
<!--Service配置-->
<bean name="userService" class="com.legend.ssh.service.imp.UserServiceImp"></bean>
</beans>
- Dao持久层
1、编写Dao层接口和实现类，然后操作数据库
public interface UserDao {
// 根据用户登录名称查询user对象
User getByUserName(String userName);
}
2、UserDaoImp.java实现类：通过Spring整合的Hibernate模板中的HQL或Criteria的方式操作数据库
/**
* 模板操作数据库，将dao注入SessionFactory
*/
public class UserDaoImp extends HibernateDaoSupport implements UserDao {
@Override
public User getByUserName(final String userName) {
// HQL方式
/* User user = getHibernateTemplate().execute(new HibernateCallback<User>() {
@Override
public User doInHibernate(Session session) throws HibernateException {
String hql = "from User where user_name = ?";
Query query = session.createQuery(hql);
query.setParameter(0, userName);
User user = (User) query.uniqueResult();
return user;
}
});
return user;*/
// Criteria
DetachedCriteria criteria = DetachedCriteria.forClass(User.class);
criteria.add(Restrictions.eq("user_name", userName));
List<User> userList = (List<User>) getHibernateTemplate().findByCriteria(criteria);
if (userList != null && userList.size() > 0) {
return userList.get(0);
}else {
return null;
}
}
}
3、由于Spring要整合Hibernate环境来操作数据库，则需要在Spring配置中将Dao注入到SessionFactory对象中：
<!--Dao配置-->
<bean name="userDao" class="com.legend.ssh.dao.UserDaoImp">
<property name="sessionFactory" ref="sessionFactory"></property>
</bean>
4、编写测试类进行测试，其中Dao也是通过Spring进行管理获取的
@Test
public void func2() {
ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
UserDao userDao = (UserDao) context.getBean("userDao");
User user = userDao.getByUserName("legend");
System.out.println(user);
}
AOP整合
1、通过SpringAOP来管理事务的话，首先在Spring配置文件中配置核心事务管理器：
<!--核心事务管理器-->
<bean name="transactionManager" class="org.springframework.orm.hibernate5.HibernateTransactionManager">
<property name="sessionFactory" ref="sessionFactory"></property>
</bean>
核心事务管理器配置完成后，可以开始在Spring配置文件中来配置事务，有两种方式配置事务：XML配置事务 和 注解配置事务。
XML配置事务
在Spring配置文件中配置事务相关的内容：
<!--核心事务管理器-->
<bean name="transactionManager" class="org.springframework.orm.hibernate5.HibernateTransactionManager">
<property name="sessionFactory" ref="sessionFactory"></property>
</bean>
<!--配置通知-->
<tx:advice id="txAdvice" transaction-manager="transactionManager">
<tx:attributes>
<tx:method name="save*" isolation="REPEATABLE_READ" propagation="REQUIRED" read-only="false" />
<tx:method name="persist*" isolation="REPEATABLE_READ" propagation="REQUIRED" read-only="false" />
<tx:method name="update*" isolation="REPEATABLE_READ" propagation="REQUIRED" read-only="false" />
<tx:method name="modify*" isolation="REPEATABLE_READ" propagation="REQUIRED" read-only="false" />
<tx:method name="delete*" isolation="REPEATABLE_READ" propagation="REQUIRED" read-only="false" />
<tx:method name="remove*" isolation="REPEATABLE_READ" propagation="REQUIRED" read-only="false" />
<tx:method name="get*" isolation="REPEATABLE_READ" propagation="REQUIRED" read-only="true" />
<tx:method name="find*" isolation="REPEATABLE_READ" propagation="REQUIRED" read-only="true" />
<tx:method name="transfer" isolation="REPEATABLE_READ" propagation="REQUIRED" read-only="false" />
</tx:attributes>
</tx:advice>
<!-- 配置将通知织入目标对象 -->
<aop:config >
<!--配置切点-->
<aop:pointcut id="txPc" expression="execution(* com.legend.ssh.service.imp.UserServiceImp.*(..))"/>
<!--配置切面-->
<aop:advisor advice-ref="txAdvice" pointcut-ref="txPc"/>
</aop:config>
注解配置事务
1、注解事务需要在Spring的配置文件中加入如下配置即可：
<!--开启注解事务-->
<tx:annotation-driven transaction-manager="transactionManager"></tx:annotation-driven>
2、在Service层的方法中添加注解，如果所有方法都需要注解可以直接添加到Service的实现类上。
@Transactional(isolation = Isolation.REPEATABLE_READ, propagation = Propagation.REQUIRED, readOnly = true)
public class UserServiceImp implements UserService{
private UserDao userDao;
@Override
public User getUserByCodePassword(User user) {
System.out.println("111111111111");
return null;
}
@Transactional(isolation = Isolation.REPEATABLE_READ, propagation = Propagation.REQUIRED, readOnly = false)
@Override
public void saveUser(User user) {
userDao.save(user);
}
public void setUserDao(UserDao userDao) {
this.userDao = userDao;
}
}
3、Dao层的实现类UserDaoImp中添加保存用户的方法：
// 注册的方法
@Override
public void save(User user) {
getHibernateTemplate().save(user);
}
4、测试事务前，我们需要将UserDao在Spring中注入到Service对象中：
<!--Service配置-->
<bean name="userService" class="com.legend.ssh.service.imp.UserServiceImp">
<property name="userDao" ref="userDao"></property>
</bean>
<!--Dao配置-->
<bean name="userDao" class="com.legend.ssh.dao.UserDaoImp">
<property name="sessionFactory" ref="sessionFactory"></property>
</bean>
5、以后我们获取Dao对象只需要将userDao当成属性，并生成SetXXX方法即可获取UserDao对象，下面我们编写测试类
@Test
public void func3() {
ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
UserService service = (UserService) context.getBean("userService");
User user = new User();
user.setUser_name("legend");
user.setUser_password("123456");
user.setNck_Name("legend");
service.saveUser(user);
}