struts2.3.24+spring4.1.6+hibernate4.3.11+mysql5.5.25开发环境搭建图文教程

struts2.3.24+spring4.1.6+hibernate4.3.11+mysql5.5.25开发环境搭建图文教程

struts2.3.24 + spring4.1.6 + hibernate4.3.11+ mysql5.5.25开发环境搭建及相关说明。

一、目标

1、搭建传统的ssh开发环境，并成功运行（插入、查询）

2、了解c3p0连接池相关配置

3、了解验证hibernate的二级缓存，并验证

4、了解spring事物配置，并验证

5、了解spring的IOC(依赖注入)，将struts2的action对象（bean）交给spring管理，自定义bean等...并验证

6、了解spring aop（面向切面编程），并编写自定义切面函数，验证结果

二、前期准备

开发环境：eclipse for java ee；mysql5.5.25；jdk1.7.0_79；navicat10.1.7(可选)；

创建数据库demo：

/*

Navicat MySQL Data Transfer

Source Server : localhost_3306

Source Server Version : 50519

Source Host : localhost:3306

Source Database : demo

Target Server Type : MYSQL

Target Server Version : 50519

File Encoding : 65001

Date: 2016-01-09 23:36:02

*/

SET FOREIGN_KEY_CHECKS=0;

-- ----------------------------

-- Table structure for `user`

-- ----------------------------

DROP TABLE IF EXISTS `user`;

CREATE TABLE `user` (

`id` bigint(20) NOT NULL AUTO_INCREMENT,

`account` varchar(200) NOT NULL,

`name` varchar(200) NOT NULL,

`address` varchar(1000) NOT NULL,

PRIMARY KEY (`id`)

) ENGINE=InnoDB DEFAULT CHARSET=utf8;

新建web工程，目录结构如下：

jar包准备，放到WEB-INF的lib目录下（有兴趣的可以用maven管理过程，但是有时候下载jar包很慢...）

相关jar包都可以在下载下来的struts、spring、hibernate中找到，这里给个参考，有些是可以删除的，比如spring mvc部分的jar包：

三、配置web.xml

配置一个struts2的filter，映射所有*.action请求，由StrutsPrepareAndExecuteFilter对象来处理；

配置context-param参数，指定spring配置文件的路径，中的参数可以用ServletContext.getInitParameter（“param-name”）来获取；

配置listener，主要是读取applicationContext.xml配置文件信息，创建bean等初始化工作；

SSH

struts2

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

struts2

*.action

contextConfigLocation

classpath:applicationContext.xml

org.springframework.web.context.ContextLoaderListener

index.jsp

四、配置applicationContext.xml

配置自动扫描ssh包下的@Repostory，@Service等注解，并生成对应的bean；

配置数据源（jdbc连接池为c3p0，可以参考c3p0的详细配置），连接池主要作用是快速提供connection，重复利用，不需要每次销毁创建，需配置用户名、密码、最大连接数、最小连接数、初始连接数等相关参数；

配置sessionFactory（可以参考hibernate的详细配置，这里配置开启二级缓存），主要作用是提供session，执行sql语句；这里我们将会通过HibernateTemplate来对数据库进行操作，方便spring进行实物控制；ps，hibernate配置中还要配置类与数据库表的映射；

配置事务管理器bean为HibernateTransactionManager，并把成员属性sessionFactory初始化为之前配置的sessionFactory bean；

配置事务的传播特性，并配置一个切面引用它，对所有ssh.service包及子包下所有add、delete、update、save方法进行事务控制，还可以配置事务传播行为等参数；

最后是一个自定义aop相关配置，对ssh.aop.AopTest下所有test开头的方法应用自定义切面‘myAop'进行控制，后续会验证结果；

xmlns:p="http://springframework.org/schema/p"

xmlns:context="http://springframework.org/schema/context"

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

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

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

xmlns:jdbc="http://springframework.org/schema/jdbc"

xsi:schemaLocation="

http://springframework.org/schema/beans

http://springframework.org/schema/beans/spring-beans.xsd

http://springframework.org/schema/aop

http://springframework.org/schema/aop/spring-aop.xsd

http://springframework.org/schema/tx

http://springframework.org/schema/tx/spring-tx-4.1.xsd

http://springframework.org/schema/jdbc

http://springframework.org/schema/jdbc/spring-jdbc-4.1.xsd

http://springframework.org/schema/context

http://springframework.org/schema/context/spring-context-4.1.xsd">

org.hibernate.dialect.MySQLDialect

true

update

thread

true

org.hibernate.cache.ehcache.EhCacheRegionFactory

true

ehcache.xml

classpath:ssh/model/User.hbm.xml

class="org.springframework.orm.hibernate4.HibernateTransactionManager">

xmlns:p="http://springframework.org/schema/p"

xmlns:context="http://springframework.org/schema/context"

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

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

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

xmlns:jdbc="http://springframework.org/schema/jdbc"

xsi:schemaLocation="

http://springframework.org/schema/beans

http://springframework.org/schema/beans/spring-beans.xsd

http://springframework.org/schema/aop

http://springframework.org/schema/aop/spring-aop.xsd

http://springframework.org/schema/tx

http://springframework.org/schema/tx/spring-tx-4.1.xsd

http://springframework.org/schema/jdbc

http://springframework.org/schema/jdbc/spring-jdbc-4.1.xsd

http://springframework.org/schema/context

http://springframework.org/schema/context/spring-context-4.1.xsd">

org.hibernate.dialect.MySQLDialect

true

update

thread

true

org.hibernate.cache.ehcache.EhCacheRegionFactory

true

ehcache.xml

classpath:ssh/model/User.hbm.xml

class="org.springframework.orm.hibernate4.HibernateTransactionManager">

class="org.springframework.orm.hibernate4.HibernateTransactionManager">

五、配置struts.xml

配置struts.objectFactory常数为spring，表示action由通过spring的bean中获取；

配置result type为"json"，也可以配置其它的，这里为了前后端数据交互简便，配置成json格式；

配置两个action，addUser和queryAllUser；

"-//Apache Software Foundation//DTD Struts Configuration 2.3//EN"

"http://struts.apache.org/dtds/struts-2.3.dtd">

json

text/html

.

.

六、编写相关代码

注意事项：

dao继承HibernateDaoSupport类，所有数据库相关操作用hibernateTemplate操作；

给dao层，service层，action添加相应注解，注册为spring的bean；

附代码如下：

UserAction.java

package ssh.action;

import java.io.PrintWriter;

import java.util.List;

import javax.annotation.Resource;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

import org.apache.log4j.Logger;

import org.apache.struts2.ServletActionContext;

import org.springframework.stereotype.Controller;

import ssh.aop.AopTest;

import ssh.model.User;

import ssh.service.UserService;

import com.google.gson.Gson;

@Controller

public class UserAction {

Logger logger = Logger.getLogger(UserAction.class);

@Resource

private UserService userService;

@Resource

private AopTest aopTest;

public void addUser(){

PrintWriter out = null;

try{

HttpServletRequest request = ServletActionContext.getRequest();

HttpServletResponse response = ServletActionContext.getResponse();

response.setContentType("text/html;charset=UTF-8");

String account = request.getParameter("account");

String name = request.getParameter("name");

String address = request.getParameter("address");

User user = new User();

user.setAccount(account);

user.setAddress(address);

user.setName(name);

userService.add(user);

out = response.getWriter();

out.write(new Gson().toJson("success"));

}catch(Exception e){

e.printStackTrace();

logger.error(e.getMessage());

if(out != null)

out.write(new Gson().toJson("fail"));

}finally{

out.flush();

out.close();

}

}

public void queryAllUser(){

PrintWriter out = null;

aopTest.test1();

aopTest.test2();

//logger.error("i");

try {

HttpServletResponse response = ServletActionContext.getResponse();

response.setContentType("text/html;charset=UTF-8");

Gson gson = new Gson();

List userList= userService.queryAllUser();

String gsonStr = gson.toJson(userList);

out = response.getWriter();

out.write(gsonStr);

} catch (Exception e) {

e.printStackTrace();

logger.error(e.getMessage());

if(out != null)

out.write(new Gson().toJson("fail"));

}finally{

out.flush();

out.close();

}

}

}

AopTest.java

package ssh.aop;

public class AopTest {

public void test1(){

System.out.println("AopTest test1 method is running~");

}

public void test2(){

System.out.println("AopTest test2 method is running~");

}

}

MyAop.java

package ssh.aop;

public class MyAop {

public void before(){

System.out.println("befor~");

}

public void after(){

System.out.println("after~");

}

}

BaseDao.java

package ssh.dao.base;

import javax.annotation.Resource;

import org.hibernate.SessionFactory;

import org.springframework.orm.hibernate4.support.HibernateDaoSupport;

public class BaseDao extends HibernateDaoSupport{

@Resource

public void setMySessionFactory(SessionFactory sessionFactory){

this.setSessionFactory(sessionFactory);

}

}

UserDao.java

package ssh.dao;

import java.util.ArrayList;

import java.util.List;

import org.springframework.orm.hibernate4.HibernateTemplate;

import org.springframework.stereotype.Repository;

import ssh.dao.base.BaseDao;

import ssh.model.User;

@Repository

public class UserDao extends BaseDao{

public void add(User user){

this.getHibernateTemplate().save(user);

}

@SuppressWarnings("unchecked")

public List queryAllUser(){

List users = new ArrayList();

HibernateTemplate hibernateTemplate = this.getHibernateTemplate();

hibernateTemplate.setCacheQueries(true);

users = (List) hibernateTemplate.find("from User");

hibernateTemplate.setCacheQueries(false);

return users;

}

}

User.java

package ssh.model;

import java.io.Serializable;

public class User implements Serializable{

/**

*

*/

private static final long serialVersionUID = -6190571611246371934L;

private Long id;

private String account;

private String name;

private String address;

public String getAccount() {

return account;

}

public String getName() {

return name;

}

public String getAddress() {

return address;

}

public void setAccount(String account) {

this.account = account;

}

public void setName(String name) {

this.name = name;

}

public void setAddress(String address) {

this.address = address;

}

/**

* @return the id

*/

public Long getId() {

return id;

}

/**

* @param id the id to set

*/

public void setId(Long id) {

this.id = id;

}

}

User.hbm.xml

"-//Hibernate/Hibernate Mapping DTD 3.0//EN"

"http://hibernate.org/dtd/hibernate-mapping-3.0.dtd">

UserService.java

package ssh.service;

import java.util.List;

import javax.annotation.Resource;

import org.springframework.stereotype.Service;

import ssh.dao.UserDao;

import ssh.model.User;

@Service

public class UserService {

@Resource

private UserDao userDao = new UserDao();

public List queryAllUser(){

return userDao.queryAllUser();

}

public void add(User user){

userDao.add(user);

}

}

index.jsp（记得添加jquery库）

<%@ page language="java" contentType="text/html; charset=UTF-8"

pageEncoding="UTF-8"%>

七、验证结果

回到开头，开始熟悉了解相关技术，并验证结果

1、搭建传统的ssh开发环境，并成功运行（插入、查询）

如下图：查询及添加用户成功；

2、了解c3p0连接池相关配置

数据库连接是一种昂贵的资源，开启及关闭比较消耗性能，因此可以用连接池来管理，初始化若干个连接，重复使用，而不是重复创建关闭，有点类似线程池；

配置如下，要根据实际项目情况合理配置最小最大连接数，详细的各个参数含义可以参考链接

另外要验证连接数相关配置很简单，可以自己写个程序验证，比如当配置最大连接数为10的时候，可以写个程序验证，当打开10个connection后，第11个connection会一直处于等待状态，获取不到；所以要根据情况合理配置连接数，否则有可能会影响应用性能；

3、了解验证hibernate的二级缓存，并验证

hibernate的一级缓存是指session范围的缓存，默认开启，二级缓存是sessionFactory范围缓存，在配置sessionFactory的时候，我们已经配置二级缓存为ehcache，接下来验证效果，查询user操作，发现第一次查询会操作数据库，打印sql语句，刷新页面后，发现查询成功且没打印sql语句，如下图，可见二级缓存工作OK；

4、了解spring事物配置，并验证

所谓事务控制，原理都一样，就是要保证原子性、一致性、隔离性、持久性，jdbc编程的时候，都是自己控制，通过set autocommit=false设置成不自动提交，然后开始写具体的数据库操作，发生异常的时候rollback，否则commit；其实spring对事物的控制原理也差不多，加了一些封装，配置等，更加方便而已，比如可以在service层不同方法进行控制等；

验证的话很简单，在service层某个方法（注意方法名要符合spring配置文件中配置的规则）内写两个插入user的操作，在中间抛出一个异常，然后执行，如果发现第一个user插入成功，说明事务控制失效，否则ok；

5、了解spring的IOC(依赖注入)，将struts2的action对象（bean）交给spring管理，自定义bean等...并验证

仔细观察的话，在配置applicationContext.xml文件的过程中，主要工作都是在配置bean相关信息，这些bean都是事先创建好的，其实所谓的bean就是对象；

之所以把对象的创建交给spring容器，目的是为了解耦；

另外在用struts的时候，spring把action注册为bean，默认是单例的，访问的时候并不是每次都new出一个action，在并发访问的时候，会有风险；

不过，可以通过scope="prototype"，把action配置成多例；ps：struts2中的action默认是多例；

注意：applicationContext.xml配置的bean和自定义注解的bean都是可以在程序运行的过程中直接获取的，通过@Resource等方式，这个很好验证，写个小程序即可；

6、了解spring aop（面向切面编程），并编写自定义切面函数，验证结果

切面编程这种形式很多地方都用了该思想，什么过滤器，拦截器，事务控制等等...

其原理还是java的反射和动态代理，在方法执行前后加以控制，加入自己要执行的代码；

小例子中加了个切面，在方法执行前后打印before和after字符串，如下图，工作正常，代码参考前面部分：

@author   风一样的码农

版权声明：本文内容由网络用户投稿，版权归原作者所有，本站不拥有其著作权，亦不承担相应法律责任。如果您发现本站中有涉嫌抄袭或描述失实的内容，请联系我们jiasou666@gmail.com 处理，核实后本网站将在24小时内删除侵权内容。