spring整合hibernate与struts2

最新推荐文章于 2021-11-02 10:41:22 发布

AYZXX

最新推荐文章于 2021-11-02 10:41:22 发布

阅读量740

点赞数 1

分类专栏： java SSH 文章标签： SSH框架最简单整合

本文链接：https://blog.csdn.net/AYZXX/article/details/84403887

版权

java 同时被 2 个专栏收录

13 篇文章 0 订阅

订阅专栏

SSH

1 篇文章 0 订阅

订阅专栏

１java的主流的三大框架，spring,hibernate,struts2,

(1)hibernates是一个持久层的轻量级的开源框架，在模式MVC中dao层。

(2)struts2是表现层框架。

(3)spring出现在三层之中，所以用来spring整合其他两个框架。

２，学习的框架的第一步，是学会导包：每个框架需要导的包大部分都不相同，有相同的还需要我们去重，而且有的包导了就必须用，否则会报错，下面会一一详解。

hibernate: 1: 数据库驱动包(必导的)

2:hibernate的核心jar包(在hibernate/lib/required下面的所有)

3:hibernate/lib/jpa | java persist api java的持久化规范(接口)

struts2:1:struts2-blank.war/WEB-INF/lib/下所以的核心包(注意:javassist-3.18.1-GA.jar包与hibernate中的重复,需要去重)

　　　２:struts2整合spring 插件的包(这个包一旦导入,那么struts2在启动时就会寻找spring容器.找不到将会抛出异常)

2:整合web的包(spring-web)

3:整合AOP4个(spring-aop|spring-aspect|aop联盟|aopweaving)

4:整合hibernate和AOP事物4个(spring-jdbc|spring-tx|c3p0|spring-orm)

　　　5:正junit4测试:test包(spring-test)

标签库：２个(jstl-1.2.jar和standard.jar)　

３，导包完成，表示整合的工作已经完成一小半，下面的步骤是spring先整合hibernate在整合struts2，因此我们创建一个spring的核心配置文件applicationContext.xml　并导入约束如下：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
xmlns="http://www.springframework.org/schema/beans"
 xmlns:tx="http://www.springframework.org/schema/tx" 
 xmlns:aop="http://www.springframework.org/schema/aop" 
 xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.2.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.2.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.2.xsd ">

然后编写配置c3p0连接池：(这些代码都是不变的，改一下密码和用户名就可以用)　

<bean name ="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
     <property name="driverClass" value="com.mysql.jdbc.Driver"></property>
     <property name="jdbcUrl" value="jdbc:mysql:///restrant"></property>
     <property name="user" value="root"></property>
     <property name="password" value="AYZXX"></property>
     <property name="minPoolSize" value="5"></property>
     <property name="maxPoolSize" value="10"></property>
</bean>

在配置工厂和事物：里面有引入其他的配置文件，上面有注明的：

<bean name="sessionFactory" class="org.springframework.orm.hibernate5.LocalSessionFactoryBean">
     
     <property name="dataSource">
         <ref bean="dataSource" />
     </property>
     <property name="hibernateProperties">
         <props>
             <prop key="hibernate.dialect"> 
             org.hibernate.dialect.MySQLDialect 
             </prop>
         </props>
     </property>
     <!-- 引入hibernate的配置  -->
     <property name="mappingResources">
         <list>
             <value>cn/digital/entity/Users.hbm.xml</value>
         </list>
     </property>
 </bean>
 
 
<bean name="transactionManager" class="org.springframework.orm.hibernate5.HibernateTransactionManager">
     <property name="sessionFactory" ref="sessionFactory"></property>
</bean>

上面配置文件中，引入其他的配置文件，因此下面就是对引入的文件的介绍：hibernate的配置文件

首先我们编写一个简单的bean类(这个类中的属性需要与数据库中的对应，名称可以不同，但是最好相同)：

package cn.digital.entity;

public class UserInfo {
    private int Id;
    private String loginNmae;
    private String loginPwd;
	public int getId() {
		return Id;
	}
	public void setId(int id) {
		Id = id;
	}
	public String getLoginNmae() {
		return loginNmae;
	}
	public void setLoginNmae(String loginNmae) {
		this.loginNmae = loginNmae;
	}
	public String getLoginPwd() {
		return loginPwd;
	}
	public void setLoginPwd(String loginPwd) {
		this.loginPwd = loginPwd;
	}
	@Override
	public String toString() {
		return "UserInfo [Id=" + Id + ", loginNmae=" + loginNmae + ", loginPwd=" + loginPwd + "]";
	}
}

在编写一个与之相对应的:hibernate配置文件（最好房子同一包下，好找，好改错）

<?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="cn.digital.entity">
    <class name="UserInfo" table="users" catalog="restrant">
        <!--配置主键-->
        <id name="id" >
            <column name="id"></column>
            <generator class="native"></generator>
        </id>
    <!--配置属性映射-->
    <property name="loginNmae" >
         <column name="loginNmae" length="20" not-null="true"></column>
    </property>
    
     <property name="loginPwd" >
         <column name="LoginPwd" length="20" not-null="true"></column>
    </property>   
    </class>
</hibernate-mapping>

引入的配置文件编写完毕，这个时候就需要测试，（最好一步一个测试，不然最后死的很惨，尤其是新手）

这个时候主要测试spring的核心配置文件是否正确，因此，需要编写一个测试方法，里面只要能加载配置文件即可。（注意多测试几次，改一点，测试一次）

package com.digital.test;

import org.junit.Test;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Demo1 {
	@Test
	public void fun(){
		
	ClassPathXmlApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
	
	}
}

上面的都正确后，然后进行整合，即主要的是：让hibernate使用spring的事物.(在核心配置文件中)

<!-- 定义事物通知,需要事物管理器 -->
 <tx:advice id="txAdvice" transaction-manager="transactionManager">
    <tx:attributes>
            <tx:method name="*" propagation="REQUIRED"/>
    </tx:attributes>
</tx:advice>
<aop:config>
    <aop:pointcut expression="execution(* com.restrant.service.*.*(..))" id="serviceMethods"/>
     <aop:advisor advice-ref="txAdvice" pointcut-ref="serviceMethods"/>
</aop:config>

上面写完之后，需要我们编写DAO操作，一般的情况都是先编写一个借口，然后，在实现它。

package com.restrant.dao;

import java.util.List;
import cn.digital.entity.UserInfo;
public interface UsersDao {
	public List<UserInfo> search(UserInfo cond);
}

package com.restrant.dao.impl;

import java.util.List;

import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.SessionFactory;

import com.restrant.dao.UsersDao;

import cn.digital.entity.UserInfo;

public class UsersDaoImpl implements UsersDao{

	SessionFactory sessionFactory;
	
	public SessionFactory getSessionFactory() {
		return sessionFactory;
	}

	public void setSessionFactory(SessionFactory sessionFactory) {
		this.sessionFactory = sessionFactory;
	}

	@Override 
	@SuppressWarnings("unchecked")
	
	public List<UserInfo> search(UserInfo cond) {
		
		List<UserInfo> uList = null;
		Session session=sessionFactory.getCurrentSession();
		
		String hql = "from UserInfo u where u.loginNmae = ? and u.loginPwd = ?";
		
		Query query = session.createQuery(hql);
			
		System.out.println(query);
		
		query.setParameter(0,cond.getLoginNmae());
		query.setParameter(1,cond.getLoginPwd());
		
		uList = query.list();
		return uList;
	}
}

写完这个DAO操作后，需要将它放到spring容器中，即把它配置到核心配置文件，配置完后，加载测试一下。

<!-- 实例化持久层UserDao-->
<bean name="usersdao" class="com.restrant.dao.impl.UsersDaoImpl">
   <property name="sessionFactory" ref="sessionFactory"></property>
</bean>

DAO层编写完后：向上走是service层，但是这个是最简单的整合测试(包函其他的功能，因此很简单)

package com.restrant.service;

import java.util.List;

import cn.digital.entity.UserInfo;

public interface UserService {
	
	public List<UserInfo> login(UserInfo cond);
	
}

package com.restrant.service.impl;

import java.util.List;

import com.restrant.dao.UsersDao;
import com.restrant.service.UserService;

import cn.digital.entity.UserInfo;

public class UserServiceImpl implements UserService{

	UsersDao usersdao;
	
	public UsersDao getUsersdao() {
		return usersdao;
	}

	public void setUsersdao(UsersDao usersdao) {
		this.usersdao = usersdao;
	}

	@Override
	public List<UserInfo> login(UserInfo cond) {
	  return usersdao.search(cond);
	}
}

service编写完毕同上面一样，需要放到spring容器中，所以需要配置，配置后测试一下。

<!-- 实例化UserServiceImpl类 -->
<bean name="userService" class="com.restrant.service.impl.UserServiceImpl">
   <property name="usersdao" ref="usersdao"></property>
</bean>

继续向上，应该是Action，即开始整合struts2框架了，先编写一个简单Action，

package com.restrant.action;

import java.util.List;
import com.opensymphony.xwork2.ActionSupport;
import com.restrant.service.UserService;

import cn.digital.entity.UserInfo;

public class UserAction extends ActionSupport {
	
	UserInfo user;
	UserService userService;
	
	public String doLogin()throws Exception{
		System.out.println(user);
		List<UserInfo> uList = userService.login(user);
		
		if(uList.size()>0){
			return "index";
		}else return "login";
	}

	public UserInfo getUser() {
		return user;
	}

	public void setUser(UserInfo user) {
		this.user = user;
	}

	public UserService getUserService() {
		return userService;
	}

	public void setUserService(UserService userService) {
		this.userService = userService;
	}
}

写完一个Action类，需要将他配置到struts框架中，因此在src先新建一个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>
    <constant name="struts.i18n.encoding" value="utf-8"></constant>
    <package name="restaurant" namespace="/" extends="struts-default">
            
        <action name="doLgoin" class="com.restrant.action.UserAction" method="doLogin">
           <result name="index" type="dispatcher">index.jsp</result>
           <result name="login" type="redirect">login.jsp</result>
        </action>
    
    </package>
</struts>

整合spring和struts 框架，这时我们应该将Action类放到spring 容器中，和上面的步骤一样。

<!-- 实例化UserAction -->
<bean name="userAction" class="com.restrant.action.UserAction">
    <property name="userService" ref="userService"></property>
</bean>

一般情况我们编写struts的配置文件，我们都需要在web目录下配置核心过滤器，而且我们还需要指定以Listener方式启动spring以及要把sting的核心配置文件的位置告知web.xml(编写这个，能复制就不要自己写，写完记得发布测试一下)

<!--指定以Listener方式启动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>
<!--配置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>

上面的编写完后，工作就完成 90%，下面就是两个简单的jsp。

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
</head>
<body>
     欢迎您，登陆成功！
</body>
</html>

<%@ page language="java" contentType="text/html; charset=UTF-8"
	pageEncoding="UTF-8"%>
<%@taglib uri="/struts-tags" prefix="s"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
</head>
<body>
    <s:form action="doLgoin" method="post">
        <table>
             <tr>
                 <s:textfield name="user.loginNmae" label="用户名"/>
             </tr>
             <tr>
                  <s:textfield name="user.loginPwd" label="密码 "/>
             </tr>
             <tr>
                 <s:submit value="登陆 "/>
             </tr>
        </table>
     </s:form>
</body>
</html>

总结：到此已经结束，这是一个最简单的三大框架整合程序，但是在此其间，我遇到的问题，真是一言难尽，首先，我一开始编写了很多的代码，但是一测试，错了，根本无从下手。然后，本人由于英语问题，一些单词经常容易拼错，所以测试的时候，报了很多的未知错误，我很不喜欢英语，但是为了改错，硬着头皮看，最后发现很多都是名词不一致的错误，很崩溃。实验室没人学java根本没人问，没人帮忙找错，都是自己一个人弄的，中间经历了无数的坑，遇见各种问题，但是收获也是很多的，总归是进步的。

本人是新手，上面很多不足，希望包函。

源码：https://download.csdn.net/download/ayzxx/10805405