SSH框架整合

一． 数据库

a) 建库（UTF-8）

二． web工程

a) 创建工程（UTF-8）

b) 资源文件分类

i. 配置文件：config

ii. 测试文件：test

iii. WebRoot下：

1. 通用文件：common

2. 样式文件：css

3. 脚本文件：js

4. 图片文件：images

5. 上传文件：upload

c) 添加jar包（U盘mylib中）

i. Junit

ii. Log4j

iii. Sql

iv. Struts2

v. Spring

vi. Hibernate

vii. Struts-spring

d) 整合SSH

i. 配置Struts

1. 在config中添加struts.xml

2. 在web.xml中配置struts的主过滤器

  <!-- 配置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>

 

ii. 配置hibernateant

1. 在config中添加hibernate.cfg.xml配置文件

2. 添加jdbc.properties配置文件，并修改相关信息

iii. 配置spring

1. 在config中添加applicationContext.xml，并修改自动扫描与装配bean

iv. 整合spring和hibernate

1. 添加完applicationContext.xml，整合就完成了

v. 整合Struts和spring

1. 整合的jar包struts2-spring-plugin-2.1.8.1.jar

2. 在web.xml中配置Spring的监听器

<!-- 配置Spring的监听器，用于初始化ApplicationContext对象 -->

<listener>

<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>

</listener>

<context-param>

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

<param-value>classpath:applicationContext*.xml</param-value>

</context-param>

 

vi. 测试整合结果

1. 在test文件夹下创建SpringTest.java

package com.ssh.app.test;

 

import org.hibernate.SessionFactory;

import org.junit.Test;

import org.springframework.context.ApplicationContext;

import org.springframework.context.support.ClassPathXmlApplicationContext;

 

 

public class SpringTest {

private ApplicationContextac =new ClassPathXmlApplicationContext("applicationContext.xml");

//测试SessionFactory

@Test

public void testSessionFactory()throws Exception{

SessionFactory sessionFactory = (SessionFactory) ac.getBean("sessionFactory");

System.out.println(sessionFactory);

}

//测试事务

@Test

public void testTransaction()throws Exception{

TestService testService = (TestService) ac.getBean("testService");//不能new，会报空指针

testService.saveTwoUsers();

}

}

 

 

2. 在test文件夹下创建TestService.java

package com.ssh.app.test;

 

import javax.annotation.Resource;

 

import org.hibernate.Session;

import org.hibernate.SessionFactory;

import org.springframework.stereotype.Service;

import org.springframework.transaction.annotation.Transactional;

 

import com.ssh.app.domain.User;

 

 

//@Service("testService")括号也可以不写，默认是类名，开头字母小写

@Service("testService")

public class TestService {

 

@Resource

private SessionFactory sessionFactory;

//@Transactional开事务，写在类上也行

@Transactional

public void saveTwoUsers(){

Session session = sessionFactory.getCurrentSession();//getCurrentSession()有人管理事务；openSession()开启新的sessionFactory没人管理事务

session.save(new User());

// int a = 1/0;

session.save(new User());

}

}

 

3. 在src文件夹下创建实体类User.java和映射文件User.hbm.xml

User.java

package com.ssh.app.domain;

 

public class User {

 

private long id;

private String name;

public long getId() {

return id;

}

public void setId(long id) {

this.id = id;

}

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

}

 

User.hbm.xml

<?xml version="1.0"?>

<!DOCTYPE hibernate-mapping PUBLIC

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

        "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

 

<hibernate-mapping package="com.ssh.app.domain">

 

<class name="User" table="t_user">

<id name="id">

            <generator class="native"/>

</id>

<property name="name"/>

</class>

</hibernate-mapping>

 

 

4. 将配置好的User.hbm.xml放入hibernate.cfg.xml

<!-- 导入映射配置 -->

<mapping resource="com/ssh/app/domain/User.hbm.xml" />

 

5. 使用单元测试运行SpringTest.java中的两个方法测试SessionFactory和事务

6. 在test文件下创建TestAction.java

package com.ssh.app.test;

 

import javax.annotation.Resource;

 

import org.springframework.context.annotation.Scope;

import org.springframework.stereotype.Controller;

 

import com.opensymphony.xwork2.ActionSupport;

 

/**

 * 在action中调用service，service里面保存到数据库

 * @author Administrator

 *

 */

@Controller

@Scope("prototype")

public class TestAction extends ActionSupport{

 

@Resource

private TestService testService;

@Override

public String execute() throws Exception {

System.out.println("-------> TestAction.execute()");

testService.saveTwoUsers();

return "success";

}

}

 

 

7. 在struts.xml中配置action

<!-- 测试用的action，当与Spring整合后，class属性写的就是Spring中bean的名称 -->

<action name="test" class="com.ssh.app.test.TestAction">

<result name="success">/test.jsp</result>

</action>

 

8. 在WebRoot下新建一个test.jsp

9. 将项目部署到tomcat中，运行

10. 在浏览器中输入http://127.0.0.1:8080/SSHBase/test.action，显示test.jsp页面，控制台打印信息，数据库新增两条数据，说明成功

三． 配置日志工具

a) 在config文件夹中添加log4j.properties，修改编码格式UTF-8，修改其中必要的配置信息

b) 测试log，在test文件夹下创建TestLog.java

package com.ssh.app.test;

 

import org.apache.commons.logging.Log;

import org.apache.commons.logging.LogFactory;

import org.junit.Test;

 

public class TestLog {

@Test

public void testLog() {

Log log = LogFactory.getLog(getClass());

try {

int i = 1/0;

} catch (Exception e) {

// TODO: handle exception

log.error(e.getMessage());

e.printStackTrace();

}

log.debug("debug级别日志");

log.info("info级别日志");

log.warn("warn级别日志");

log.error("error级别日志");

log.fatal("fatal级别日志");

}

 

 

}

 

 

c) 运行看结果

四． 编写基类

DAO基类中配备增删改查的操作。

a) 在src下新建一个core.dao包，创建一个接口类BaseDao.java

package com.ssh.demo.core.dao;

 

import java.util.List;

 

public interface BaseDao<T> {

 

/**

 * 新增

 */

public void save(T entity);

/**

 * 更新

 */

public void update(T entity);

/**

 * 根据id删除

 */

public void delete(Long id);

/**

 * 查询实体，如果id为null，则返回null，并不会抛异常。

 *

 * @param id

 * @return

 */

public T findObjectById(Long id);

 

/**

 * 查询实体

 *

 * @param ids

 * @return

 */

public List<T> findObjectByIds(Long[] ids);

/**

 * 查找列表

 */

public List<T> findObjects();

 

}

 

 

b) 在src下新建一个core.dao.impl包，创建一个接口类BaseDaoImpl.java，并实现BaseDao接口

package com.ssh.demo.core.dao.impl;

 

import java.lang.reflect.ParameterizedType;

import java.util.Collections;

import java.util.List;

 

import javax.annotation.Resource;

 

import org.hibernate.Query;

import org.hibernate.Session;

import org.hibernate.SessionFactory;

 

import com.ssh.demo.core.dao.BaseDao;

 

public abstract class BaseDaoImpl<T> implements BaseDao<T>{

@Resource

private SessionFactory sessionFactory;

public Class<T> clazz;

@SuppressWarnings("unchecked")

public BaseDaoImpl(){

//使用反射得到T的真实类型

ParameterizedType pt = (ParameterizedType) this.getClass().getGenericSuperclass();//BaseDaoImpl<User>

this.clazz = (Class<T>) pt.getActualTypeArguments()[0];

}

 

public void save(T entity) {

getSession().save(entity);

}

 

public void update(T entity) {

getSession().update(entity);

}

 

public void delete(Long id) {

getSession().delete(findObjectById(id));

}

 

@SuppressWarnings("unchecked")

public T findObjectById(Long id) {

if (id == null) {

return null;

}

return (T) getSession().get(clazz, id);

}

 

@SuppressWarnings("unchecked")

public List<T> findObjectByIds(Long[] ids) {

if (ids == null || ids.length == 0) {

return Collections.EMPTY_LIST;

}

return getSession().createQuery(//

"FROM " + clazz.getSimpleName() + " WHERE id IN(:ids)")//

.setParameterList("ids", ids)//

.list();

}

 

@SuppressWarnings("unchecked")

public List<T> findObjects() {

Query query = getSession().createQuery("FROM "+clazz.getSimpleName());

return query.list();

}

 

/**

 * 获取当前可用的Session

 *

 * @return

 */

protected Session getSession() {

return sessionFactory.getCurrentSession();

}

}

 

 

获取泛型类型：

// 使用反射得到T的真实类型

ParameterizedType pt = (ParameterizedType) this.getClass().getGenericSuperclass(); //获取当前new的对象的 泛型的父类 类型

this.clazz = (Class<T>) pt.getActualTypeArguments()[0]; // 获取第一个类型参数的真实类型

}

 

jar包地址：