spring 框架整合 笔记4

struts hibernate spring

先贴出框架整合需要的maven

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.kaishengit</groupId>
  <artifactId>urls</artifactId>
  <packaging>war</packaging>
  <version>0.0.1-SNAPSHOT</version>
  <name>urls Maven Webapp</name>
  <url>http://maven.apache.org</url>
  <dependencies>
    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>javax.servlet-api</artifactId>
      <version>3.1.0</version>
    </dependency>
    <dependency>
      <groupId>jstl</groupId>
      <artifactId>jstl</artifactId>
      <version>1.2</version>
    </dependency>

    <!-- Spring -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-core</artifactId>
        <version>3.2.0.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-beans</artifactId>
        <version>3.2.0.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>3.2.0.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-aop</artifactId>
        <version>3.2.0.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-expression</artifactId>
        <version>3.2.0.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-aspects</artifactId>
        <version>3.2.0.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-jdbc</artifactId>
        <version>3.2.0.RELEASE</version>
    </dependency>
    <!-- orm是spring和hibernate整合需要的 -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-orm</artifactId>
        <version>3.2.0.RELEASE</version>
    </dependency>
    <!-- 和servlet结合需要的 -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-web</artifactId>
        <version>3.2.0.RELEASE</version>
    </dependency>

    <!-- Hibernate -->
    <dependency>
        <groupId>org.hibernate</groupId>
        <artifactId>hibernate-core</artifactId>
        <version>4.2.0.Final</version>
    </dependency>
    <dependency>
        <groupId>net.sf.ehcache</groupId>
        <artifactId>ehcache-core</artifactId>
        <version>2.6.6</version>
    </dependency>
    <dependency>
        <groupId>org.hibernate</groupId>
        <artifactId>hibernate-ehcache</artifactId>
        <version>4.2.0.Final</version>
    </dependency>

    <!-- Struts2 -->
    <dependency>
      <groupId>org.apache.struts</groupId>
      <artifactId>struts2-core</artifactId>
      <version>2.3.16</version>
    </dependency>
    <dependency>
        <groupId>org.apache.struts</groupId>
        <artifactId>struts2-convention-plugin</artifactId>
        <version>2.3.16</version>
    </dependency>
    <!-- struts和spring联合起来需要这个jar -->
    <dependency>
        <groupId>org.apache.struts</groupId>
        <artifactId>struts2-spring-plugin</artifactId>
        <version>2.3.16.3</version>
    </dependency>

    <!-- other -->
    <dependency>
        <groupId>javax.inject</groupId>
        <artifactId>javax.inject</artifactId>
        <version>1</version>
    </dependency>
    <dependency>
        <groupId>joda-time</groupId>
        <artifactId>joda-time</artifactId>
        <version>2.5</version>
    </dependency>
    <dependency>
        <groupId>com.google.code.gson</groupId>
        <artifactId>gson</artifactId>
        <version>2.3</version>
    </dependency>
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>5.1.33</version>
    </dependency>
    <dependency>
        <groupId>commons-dbcp</groupId>
        <artifactId>commons-dbcp</artifactId>
        <version>1.4</version>
    </dependency>

    <dependency>
        <groupId>log4j</groupId>
        <artifactId>log4j</artifactId>
        <version>1.2.17</version>
    </dependency>

  </dependencies>
  <build>
    <finalName>urls</finalName>
    <plugins>
        <plugin>
            <groupId>org.mortbay.jetty</groupId>
            <artifactId>jetty-maven-plugin</artifactId>
            <configuration>
                <scanIntervalSeconds>10</scanIntervalSeconds>
                <webApp>
                    <contextPath>/</contextPath>
                </webApp>
                <connectors>
                    <connector implementation="org.eclipse.jetty.server.nio.SelectChannelConnector">
                        <port>80</port>
                        <maxIdleTime>60000</maxIdleTime>
                    </connector>
                </connectors>
            </configuration>
        </plugin>
    </plugins>
  </build>
</project>

spring + hibernate + struts    基于注解的形式，基于xml的以后需要的话在总结

web.xml

<?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_3_0.xsd" id="WebApp_ID" version="3.0">

    <!-- OpenSessionInView
        这是一个经典的过滤器，session的范围就是事务的开启和事务的结束，也就是在service中的方法执行时开启
        方法结束关闭，这就会造成延迟加载错误，因为延迟加载的时候session已经关闭了，一个方法就是关闭延迟加载
        或者修改抓取策略或者预加载，但是这就丧失了hibernate的好处，所以我们就可以做到扩大session的范围，在请求
        到来的开启session，到响应结束的时候关闭session
        -->
    <filter>
        <filter-name>opensessioninview</filter-name>
        <filter-class>org.springframework.orm.hibernate4.support.OpenSessionInViewFilter</filter-class>
    </filter>
    <filter-mapping>
        <filter-name>opensessioninview</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

    <!-- 字符集过滤器 -->
    <filter>
        <filter-name>encoding</filter-name>
        <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
        <init-param>
            <param-name>encoding</param-name>
            <param-value>UTF-8</param-value>
        </init-param>
    </filter>
    <filter-mapping>
        <filter-name>encoding</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

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

      <!-- Spring容器      web程序是没有main函数的，所以在web容器启动的时候就要启动spring容器
    ，而随web容器启动就启动的是application   使用监听器实现-->
      <listener>
          <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
      </listener>
      <!-- 使用监听器配置web容器启动要读取的文件 -->
      <context-param>
          <param-name>contextConfigLocation</param-name>
          <param-value>classpath:applicationContext*.xml</param-value>
      </context-param>

</web-app>

读取：applicationContext.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"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:context="http://www.springframework.org/schema/context"
       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/aop http://www.springframework.org/schema/aop/spring-aop.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd"
>

    <context:component-scan base-package="com.kaishengit"/>

    <aop:aspectj-autoproxy/>

    <!-- 读取db.properties文件 使用${key}获取文件中的配置项 -->
    <context:property-placeholder location="classpath:db.properties"/>

    <!-- 数据源 -->
    <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
        <property name="driverClassName" value="${jdbc.driver}"/>
        <property name="url" value="${jdbc.url}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
    </bean>

    <!-- SessionFactory -->
    <bean id="sessionFactory" class="org.springframework.orm.hibernate4.LocalSessionFactoryBean">
        <property name="dataSource" ref="dataSource"/>
        <!-- 解决以前在hibernate中配置每次导入的类名那一步 ,将这里面的所有类当做hibernate的实体类看待-->
        <property name="packagesToScan" value="com.kaishengit.pojo"/>
        <!-- 方言,和是否显示数据库sql -->
        <property name="hibernateProperties">
            <props>
                <prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>
                <prop key="hibernate.show_sql">true</prop>
                <!-- 开启二级缓存 -->
                <prop key="hibernate.cache.region.factory_class">org.hibernate.cache.ehcache.EhCacheRegionFactory</prop>
            </props>
        </property>
    </bean>

    <!-- Hibernate事务管理器 -->
    <bean id="transactionManager" class="org.springframework.orm.hibernate4.HibernateTransactionManager">
        <property name="sessionFactory" ref="sessionFactory"/>
    </bean>

    <!-- 基于注解的事务 -->
    <tx:annotation-driven transaction-manager="transactionManager"/>

</beans>

db.properties

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql:///mydb
jdbc.username=root
jdbc.password=root

log4j.properties

log4j.appender.consoleOut=org.apache.log4j.ConsoleAppender
log4j.appender.consoleOut.layout=org.apache.log4j.PatternLayout
log4j.appender.consoleOut.layout.ConversionPattern=[%p](%d)---%l--%m\r\n
log4j.rootLogger=INFO,consoleOut

log4j.rootLogger=DEBUG,consoleOut

ehcache.xml

<?xml version="1.0" encoding="UTF-8"?>
<ehcache>

    <diskStore path="java.io.tmpdir"/>

    <defaultCache
        maxElementsInMemory="10000"
        eternal="false"
        timeToIdleSeconds="120"
        timeToLiveSeconds="120"
        overflowToDisk="true"
    />
</ehcache>

struts.xml

<?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>

    <!-- 更改Struts默认后缀 -->
    <constant name="struts.action.extension" value="action"/>
    <constant name="struts.multipart.maxSize" value="10485760"/>
    <constant name="struts.convention.default.parent.package" value="basePackage"/>

    <package name="basePackage" extends="convention-default" abstract="true">
    <!-- 如果使用了json，记得还要继承json-default
    <package name="basePackage" extends="convention-default,json-default" abstract="true">
    -->
    </package>

</struts>
时间： 2024-10-10 07:35:08

spring 框架整合 笔记4的相关文章

spring框架搭建笔记

◆简介 目的:解决企业应用开发的复杂性 功能:使用基本的JavaBean代替EJB,并提供了更多的企业应用功能 范围:任何Java应用 Spring 框架是一个分层架构,由 7 个定义良好的模块组成.Spring 模块构建在核心容器之上,核心容器定义了创建.配置和管理 bean 的方式. 组成 Spring 框架的每个模块(或组件)都可以单独存在,或者与其他一个或多个模块联合实现.每个模块的功能如下: ? 核心容器:核心容器提供 Spring 框架的基本功能.核心容器的主要组件是 BeanFac

Spring框架整合Struts2使用Validation框架验证表单用户输入数据的详细教程

原创整理不易,转载请注明出处:Spring框架整合Struts2使用Validation框架验证表单用户输入数据的详细教程 代码下载地址:http://www.zuidaima.com/share/1778685765291008.htm 在<Struts2教程4:使用validate方法验证数据>中曾讲到使用validate方法来验证客户端提交的数据,但如果使用validate方法就会将验证代码和正常的逻辑代码混在一起,但这样做并不利于代码维护,而且也很难将过些代码用于其他程序的验证.在St

spring框架整合使用定时任务框架java quartz的示例代码配置

原创整理不易,转载请注明出处:spring框架整合使用定时任务框架java quartz的示例代码配置 代码下载地址:http://www.zuidaima.com/share/1775583461723136.htm 有时候我们的任务(Job)需要再某些任务完成之后才能进行:例如从旧的数据库批量导数据的时候:需要现将被其他数据依赖的数据导入新的数据库:然后再进行关系的导入..在这种情况下我们就可以使用Quartz的listener来做文章了. 首先我们写一个主任务的类,命名为MainJob:她

spring框架整合ibatis的项目实例代码

原创整理不易,转载请注明出处:spring框架整合ibatis的项目实例代码 代码下载地址:http://www.zuidaima.com/share/1780211932679168.htm 这两天一直在研究ibatis与spring的整合 一个小小的demo搞的我头晕目眩的,但程序一旦跑起来了,突然有一种豁然开朗,重见天日,感觉生活很美好的感觉!,也许,这就是那一行行的代码带给我们的不同享受吧.呵呵,废话就不多说了. 在此先引用几句别人的资料... Spring通过DAO模式,提供了对iBA

spring,hibernate,spring框架整合

SSH框架作为javaEE最经典的框架, 初学者整合这几个框架可能也是一件比较头痛的事情(包括我自己), 下面来进行框架的整合!   一:   准备   SSH框架介绍 Struts2是一个基于MVC设计模式的Web应用框架,它本质上相当于一个servlet, 处于MVC的控制层,Struts 2是Struts的下一代产品,个人认为: struts2~~struts+xwork; Hibernate是一个开放源代码的对象关系映射框架,它对JDBC进行了非常轻量级的对象封装,它将POJO与数据库表

Spring框架整合Struts2

1,用Spring架构,及Struts2-spring-plugin插件 导入Spring的dist全部所需的jar包 Struts2的spring插件 struts2-spring-plugin.XX.jar struts2的核心包 struts2-core.XX.jar xwork- core.XX.jar commons.logging.XX.jar ...根据需要选择导入 2,配置web.xml中applicationContext.xml的参数路径及侦听器 <context-param

spring框架学习笔记（二）

配置Bean Ioc容器 Ioc容器需要实例化以后才可以从Ioc容器里获取bean实例并使用. spring提供两种方式类型的Ioc容器实现: BeanFactory:底层的,面向spring框架的. ApplicationContext :面向开发人员的,一般用这个. 有两个实现类: ClassPathXmlApplicationContext:从类路径下加载配置文件. FileSystemXmlApplicationContext:从文件系统中加载配置文件. 两种方式配置文件是相同的. 通过

spring框架学习笔记7：事务管理及案例

Spring提供了一套管理项目中的事务的机制 以前写过一篇简单的介绍事务的随笔:http://www.cnblogs.com/xuyiqing/p/8430214.html 还有一篇Hibernate的事务管理:http://www.cnblogs.com/xuyiqing/p/8449167.html 可以做个对比 Spring管理事务特有的属性: 事务传播行为:事务传播行为(propagation behavior)指的就是当一个事务方法被另一个事务方法调用时,这个事务方法应该如何进行. 例

EasyUI、Struts2、Hibernate、spring 框架整合

经历了四个月的学习,中间过程曲折离奇,好在坚持下来了,也到了最后框架的整合中间过程也只有自己能体会了. 接下来开始说一下整合中的问题和技巧: 1,  jar包导入 c3p0(2个).jdbc(1个).spring(15个).Hibernate(10个).Struts2(13个).json(3个) 及EasyUI的jquery包 2, 在src目录下新建一个实体类的包,并新建一个实体类 package com.han.entity; import java.util.Date; public cl