SSH或SSM框架整合（IDEA版+Maven）

最新推荐文章于 2024-04-02 13:36:45 发布
最新推荐文章于 2024-04-02 13:36:45 发布
阅读量430 收藏
点赞数 2
分类专栏： spring 文章标签： ssh java spring hibernate maven
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43028647/article/details/84332485
版权

SSH或SSM框架整合（IDEA版+Maven）
码云地址:
https://gitee.com/ladybirdsbeatles/SSM

1. 前言
自己从一个小白开始，经历了从网上到处找相关框架的搭建教程学习，再到公司上班后也了解到完善项目中的框架体系。为了总结一下自己学习过程，和搭建一个以后可扩展和使用的通用框架，当然还有一个重要原因是帮助一些新手,自己是新手时,也遇到很多坑。为了让小白能够看懂，当然也为了大家能够更直接方便的复制即可用，这篇文章会从较新手的角度叙述。各位大牛若有看到，不喜勿喷。
2. 简介
SSH/S2SH框架, 是Sturts2+Spring + Hibernate的缩写 / springMVC+Spring+Hibernate的缩写
SSM框架，是Spring + Spring MVC + MyBatis的缩写，这个是继SSH之后，目前比较主流的Java EE企业级框架，适用于搭建各种大型的企业级应用系统。
Spring Boot, 继SSM框架后，是现在比较主流的框架,用过spring boot你一定会爱上它,它可以说是SSM的 升级版,简化配置,一键启动,会用SSM上手spring boot就比较简单,把你从XML中解放出来. spring cloud也可以试试.(如果你是新手你可以先学spring boot,在学ssm和ssh,也可以由易到难)
2. maven
Maven是一个项目管理和整合的工具。Maven为开发者提供了一套完整的构建生命周期框架。开发团队基本不用花多少时间就能自动完成工程的基础构建配置，因为Maven使用了一个标准的目录结构和一个默认的构建生命周期。在创建报告、检查、构建和测试自动配置时，Maven可以让开发者的工作变得更简单。

目录

1.项目目录结构

在这里插入图片描述
在这里插入图片描述

2.maven依赖 pom.xml


<?xml version="1.0" encoding="UTF-8"?>
<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/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    
    <groupId>org.example</groupId>
    <artifactId>struts-spring-hibernate</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>war</packaging>
    
    <name>struts-spring-hibernate Maven Webapp</name>
    <!-- FIXME change it to the project's website -->
    <url>http://www.example.com</url>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
        <!-- 统一各个框架版本 -->
        <struts.version>2.5.22</struts.version>
        <spring.version>5.2.4.RELEASE</spring.version>
        <hibernate.version>6.0.0.Alpha4</hibernate.version>
    </properties>
    <dependencies>
        <!-- Spring 核心依赖 -->
        <!-- https://mvnrepository.com/artifact/org.springframework/spring-core -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <!--  spring-beans-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <!--spring-context-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <!-- spring-tx-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-tx</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <!--  spring-test-->
        <!-- https://mvnrepository.com/artifact/org.springframework/spring-test -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>${spring.version}</version>
            <scope>test</scope>
        </dependency>
        <!-- Spring web依赖 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-web</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <!-- 使用SpringMVC需配置 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <!-- Spring整合ORM框架依赖 -->
        <!-- 关系型数据库整合时需配置 如hibernate jpa等 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-orm</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <!-- struts2核心依赖-->
        <dependency>
            <groupId>org.apache.struts</groupId>
            <artifactId>struts2-core</artifactId>
            <version>${struts.version}</version>
        </dependency>
        <!-- struts2-convention-plugin-->
        <dependency>
            <groupId>org.apache.struts</groupId>
            <artifactId>struts2-convention-plugin</artifactId>
            <version>${struts.version}</version>
        </dependency>
        <!-- Struts2和Spring整合依赖 -->
        <dependency>
            <groupId>org.apache.struts</groupId>
            <artifactId>struts2-spring-plugin</artifactId>
            <version>${struts.version}</version>
        </dependency>
        <!-- Hibernate 核心依赖 -->
        <!-- https://mvnrepository.com/artifact/org.hibernate.orm/hibernate-core -->
        <dependency>
            <groupId>org.hibernate.orm</groupId>
            <artifactId>hibernate-core</artifactId>
            <version>${hibernate.version}</version>
        </dependency>
        <!--hibernate-entitymanager-->
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-entitymanager</artifactId>
            <version>${hibernate.version}</version>
        </dependency>
        <!--hibernate-ehcache-->
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-ehcache</artifactId>
            <version>${hibernate.version}</version>
        </dependency>
        <!-- ehcache-->
        <!-- https://mvnrepository.com/artifact/net.sf.ehcache/ehcache -->
        <dependency>
            <groupId>net.sf.ehcache</groupId>
            <artifactId>ehcache</artifactId>
            <version>2.10.4</version>
        </dependency>
        <!-- slf4j-api-->
        <!-- https://mvnrepository.com/artifact/org.slf4j/slf4j-api -->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>2.0.0-alpha1</version>
        </dependency>
        <!-- SLF4J依赖 -->
        <!-- https://mvnrepository.com/artifact/org.slf4j/slf4j-log4j12 -->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
            <version>2.0.0-alpha1</version>
            <scope>test</scope>
        </dependency>
        <!-- JavaEE API依赖-->
        <!-- https://mvnrepository.com/artifact/javax/javaee-api -->
        <dependency>
            <groupId>javax</groupId>
            <artifactId>javaee-api</artifactId>
            <version>8.0.1</version>
            <scope>provided</scope>
        </dependency>
        <!-- https://mvnrepository.com/artifact/javax.servlet/javax.servlet-api -->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>4.0.1</version>
            <scope>provided</scope>
        </dependency>
        <!-- servlet依赖. -->
        <!-- https://mvnrepository.com/artifact/javax.servlet/jstl -->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>jstl</artifactId>
            <version>1.2</version>
        </dependency>
        <!--数据库连接池-->
        <!-- https://mvnrepository.com/artifact/com.alibaba/druid -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.21</version>
        </dependency>
        <!--数据库相关-->
        <!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.19</version>
        </dependency>
        <!--阿里fastjson处理json依赖-->
        <!-- https://mvnrepository.com/artifact/com.alibaba/fastjson -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.62</version>
        </dependency>
        <!-- Lombok-->
        <!-- https://mvnrepository.com/artifact/org.projectlombok/lombok -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.10</version>
            <scope>provided</scope>
        </dependency>
        <!--commons-lang3-->
        <!-- https://mvnrepository.com/artifact/org.apache.commons/commons-lang3 -->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
            <version>3.9</version>
        </dependency>
        <!-- AspectJ依赖 -->
        <!-- https://mvnrepository.com/artifact/org.aspectj/aspectjweaver -->
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.5</version>
            <scope>runtime</scope>
        </dependency>

        <!-- https://mvnrepository.com/artifact/org.apache.logging.log4j/log4j-core -->
        <dependency>
            <groupId>org.apache.logging.log4j</groupId>
            <artifactId>log4j-core</artifactId>
            <version>2.13.1</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.apache.logging.log4j/log4j-api -->
        <dependency>
            <groupId>org.apache.logging.log4j</groupId>
            <artifactId>log4j-api</artifactId>
            <version>2.13.1</version>
        </dependency>
        <!--junit-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>

    </dependencies>

    <build>
        <finalName>struts-spring-hibernate</finalName>
        <pluginManagement><!-- lock down plugins versions to avoid using Maven defaults (may be moved to parent pom) -->
            <plugins>
                <plugin>
                    <artifactId>maven-clean-plugin</artifactId>
                    <version>3.1.0</version>
                </plugin>
                <!-- see http://maven.apache.org/ref/current/maven-core/default-bindings.html#Plugin_bindings_for_war_packaging -->
                <plugin>
                    <artifactId>maven-resources-plugin</artifactId>
                    <version>3.0.2</version>
                </plugin>
                <plugin>
                    <artifactId>maven-compiler-plugin</artifactId>
                    <version>3.8.0</version>
                </plugin>
                <plugin>
                    <artifactId>maven-surefire-plugin</artifactId>
                    <version>2.22.1</version>
                </plugin>
                <plugin>
                    <artifactId>maven-war-plugin</artifactId>
                    <version>3.2.2</version>
                </plugin>
                <plugin>
                    <artifactId>maven-install-plugin</artifactId>
                    <version>2.5.2</version>
                </plugin>
                <plugin>
                    <artifactId>maven-deploy-plugin</artifactId>
                    <version>2.8.2</version>
                </plugin>
                <!-- 打包时跳过单元测试 -->
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-surefire-plugin</artifactId>
                    <version>2.19.1</version>
                    <configuration>
                        <skipTests>true</skipTests>
                    </configuration>
                </plugin>
                <!-- 集成Tomcat插件 -->
                <plugin>
                    <groupId>org.apache.tomcat.maven</groupId>
                    <artifactId>tomcat7-maven-plugin</artifactId>
                    <version>2.2</version>
                    <configuration>
                        <path>/${project.artifactId}</path>
                    </configuration>
                </plugin>
            </plugins>
        </pluginManagement>
           <!--加入对jsp页面的指向-->
            <resource>
                <!-- 指定resources插件处理哪个目录下的资源文件 -->
                <directory>src/main/webapp</directory>
                <!--注意此次必须要放在此目录下才能被访问到 -->
                <targetPath>META-INF/resources</targetPath>
                <includes>
                    <include>**/**</include>
                </includes>
            </resource>
        </resources>
    </build>
</project>

3. springbean配置 spring-bean.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:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="
   http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
   http://www.springframework.org/schema/context
   http://www.springframework.org/schema/context/spring-context-3.0.xsd">
    <!--     spring-bean配置     -->

    <!--使用Spring要用注解的方式进行配置-->
    <!--<context:annotation-config/>-->
    <!-- 开启包扫描，并注册注解 -->
    <context:component-scan base-package="com.xiaochen.beatles"/>
</beans>

4. spring数据库配置 spring-db.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:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="
   http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
   http://www.springframework.org/schema/context
   http://www.springframework.org/schema/context/spring-context-3.0.xsd">
    <!--     spring-db配置     -->

    <!--读取属性配置文件内容-->
    <!-- 引入属性文件 -->
    <context:property-placeholder location="classpath:properties/jdbc.properties"/>
    <!--1. 配置数据源 -->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <!-- 基本属性 url、user、password -->
        <property name="driverClassName" value="${jdbc.driverClass}"/>
        <property name="url" value="${jdbc.url}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
        <!-- 配置初始化大小、最小、最大 -->
        <property name="initialSize" value="${jdbc.initialSize}"/>
        <property name="minIdle" value="${jdbc.minIdle}"/>
        <property name="maxActive" value="${jdbc.maxActive}"/>
        <!-- 配置获取连接等待超时的时间 -->
        <property name="maxWait" value="${jdbc.maxWait}"/>
        <!-- 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒 -->
        <property name="timeBetweenEvictionRunsMillis" value="${jdbc.timeBetweenEvictionRunsMillis}"/>
        <!-- 配置一个连接在池中最小生存的时间，单位是毫秒 -->
        <property name="minEvictableIdleTimeMillis" value="${jdbc.minEvictableIdleTimeMillis}"/>
        <property name="validationQuery" value="${jdbc.validationQuery}"/>
        <property name="testWhileIdle" value="${jdbc.testWhileIdle}"/>
        <property name="testOnBorrow" value="${jdbc.testOnBorrow}"/>
        <property name="testOnReturn" value="${jdbc.testOnReturn}"/>
        <!-- 打开PSCache，并且指定每个连接上PSCache的大小 -->
        <property name="poolPreparedStatements" value="${jdbc.poolPreparedStatements}"/>
        <property name="maxPoolPreparedStatementPerConnectionSize"
                  value="${jdbc.maxPoolPreparedStatementPerConnectionSize}"/>
    </bean>
    <!--配置session工厂-->
    <!-- 配置Hibernate的SessionFactory -->
    <bean id="sessionFactory" class="org.springframework.orm.hibernate5.LocalSessionFactoryBean">
        <!-- 注入连接池 -->
        <property name="dataSource" ref="dataSource"/>
        <!-- 配置Hibernate属性 -->
        <property name="hibernateProperties">
            <props>
                <!-- 是否展示SQL -->
                <prop key="hibernate.show_sql">${hibernate.show_sql}</prop>
                <!-- 是否自动创建表结构 -->
                <prop key="hibernate.hbm2ddl.auto">${hibernate.hbm2ddl.auto}</prop>
                <!-- <prop key="hibernate.dialect">org.hibernate.dialect.MySQL5InnoDBDialect</prop>-->
                <!--指定数据库方言-->
                <prop key="hibernate.dialect">${hibernate.dialect}</prop>
                <!--在控制台显示执行的数据哭操作语句（格式）-->
                <prop key="hibernate.format_sql">${hibernate.format_sql}</prop>
                <!-- <prop key="">key="hibernate.current_session_context_class">${hibernate.SpringSessionContext}</prop>-->
                <!-- 开启二级缓存 ehcache -->
                <prop key="hibernate.cache.use_second_level_cache">${hibernate.cache.use_second_level_cache}</prop>
                <prop key="hibernate.cache.use_query_cache">${hibernate.cache.use_query_cache}</prop>
                <prop key="hibernate.cache.region.factory_class">${hibernate.cache.region.factory_class}</prop>
                <prop key="hibernate.cache.provider_configuration_file_resource_path">
                    ${hibernate.cache.provider_configuration_file_resource_path}
                </prop>
            </props>
        </property>
        <!-- 扫描并加载注解过的实体类 -->
        <property name="packagesToScan" value="com.xiaochen.beatles"/>
    </bean>
</beans>

5.spring事物配置 spring-tx.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:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="
   http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd

   http://www.springframework.org/schema/tx
   http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
  ">
    <!--     spring-tx配置     -->
    <!--5. 配置事务管理器  -->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource" />
    </bean>
    <!--6. 开启注解进行事务管理   transaction-manager：引用上面定义的事务管理器-->
    <tx:annotation-driven  transaction-manager="transactionManager" />

</beans>

6.spring总配置 applicationContext.xml

   applicationContext.xml中引入所有spring-*.xml文件( 也可以将所有的配置放在  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:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">
    <!--  引入配置-->
    <import resource="classpath*:spring/spring-*.xml"/>
</beans>

7.struts2配置 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>
    <!-- 指定由spring负责action对象的创建 -->
    <constant name="struts.objectFactory" value="spring"/>

    <!-- 所有匹配*.action的请求都由struts2处理 -->
    <constant name="struts.action.extension" value="action,"/>
    <!-- 是否启用开发模式 -->
    <constant name="struts.devMode" value="true"/>
    <!-- struts配置文件改动后，是否重新加载 -->
    <constant name="struts.configuration.xml.reload" value="true"/>
    <!-- 设置浏览器是否缓存静态内容 -->
    <constant name="struts.serve.static.browserCache" value="false"/>
    <!-- 请求参数的编码方式 -->
    <constant name="struts.i18n.encoding" value="UTF-8"/>
    <!-- 每次HTTP请求系统都重新加载资源文件，有助于开发 -->
    <constant name="struts.i18n.reload" value="true"/>
    <!-- 文件上传最大值 -->
    <constant name="struts.multipart.maxSize" value="104857600"/>
    <!-- 让struts2支持动态方法调用 -->
    <constant name="struts.enable.DynamicMethodInvocation" value="true"/>
    <!-- Action名称中是否还是用斜线 -->
    <constant name="struts.enable.SlashesInActionNames" value="false"/>
    <!-- 允许标签中使用表达式语法 -->
    <constant name="struts.tag.altSyntax" value="true"/>
    <!-- 对于WebLogic,Orion,OC4J此属性应该设置成true -->
    <constant name="struts.dispatcher.parametersWorkaround" value="false"/>


    <package name="basicstruts" extends="struts-default">
        <action name="index">
            <result>/index.jsp</result>
        </action>
    </package>
    <package name="basicstruts1" extends="struts-default">
        <action name="showProduct" class="com.xiaochen.beatles.acion.ProductAction" method="show">
            <result name="show">/products.jsp</result>
        </action>
    </package>
    <package name="basicstruts3" extends="struts-default">
        <action name="showColor" class="com.xiaochen.beatles.acion.ColorAction" method="color">
            <result name="color">/color.jsp</result>
        </action>
    </package>
</struts>

8.web配置 web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://java.sun.com/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
                      http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
         version="3.0">
    <context-param>
        <param-name>log4jConfiguration</param-name>
        <param-value>log4j2.xml</param-value>
    </context-param>
    <!--配置Struts2过滤器-->
    <filter>
        <filter-name>struts2</filter-name>
        <filter-class>org.apache.struts2.dispatcher.filter.StrutsPrepareAndExecuteFilter</filter-class>
        <init-param>
            <param-name>filterConfig</param-name>
            <param-value>classpath*:struts.xml</param-value>
        </init-param>
    </filter>
    <filter-mapping>
        <filter-name>struts2</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>
    <!--  配置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>

9.log4j配置 log4j.properties

### set log levels ###  INFO
log4j.rootLogger = INFO,stdout,E
# A1 is set to be a ConsoleAppender.
log4j.appender.A1=org.apache.log4j.ConsoleAppender
# A1 uses PatternLayout.
log4j.appender.A1.layout=org.apache.log4j.PatternLayout
log4j.appender.A1.layout.ConversionPattern=%-4r [%t] %-5p %c %x - %m%n
log4j.appender.stdout = org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target = System.out
log4j.appender.stdout.layout = org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern =  %d{ABSOLUTE} %5p %c{1}:%L - %m%n
log4j.logger.org.quartz=INFO
log4j.appender.E= org.apache.log4j.DailyRollingFileAppender
log4j.appender.E.File =src/main/resources/logs/mylogs.log
log4j.appender.E.DatePattern=yyyy-MM-dd'.log'
log4j.appender.E.Threshold =INFO
log4j.appender.E.layout = org.apache.log4j.PatternLayout
log4j.appender.E.layout.ConversionPattern =%-d{yyyy-MM-dd HH\:mm\:ss}[%c] [%t\:%r] - [%p]  %m%n

#为了显示参数
log4j.logger.org.hibernate.type.descriptor.sql.BasicBinder=TRACE
log4j.loggerorg.hibernate.type.descriptor.sql.BasicExtractor=TRACE

#查看查询中命名参数的值
log4j.logger.org.hibernate.engine.QueryParameters=DEBUG
log4j.logger.org.hibernate.engine.query.HQLQueryPlan=DEBUG

10.hibernate缓存配置 ehcache.xml

<?xml version="1.0" encoding="UTF-8"?>
<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:noNamespaceSchemaLocation="http://ehcache.org/ehcache.xsd">
    <defaultCache maxElementsInMemory="10000" eternal="false"
                  timeToIdleSeconds="120" timeToLiveSeconds="120" overflowToDisk="false"/>
</ehcache>

10.测试实例

1.实体
package com.xiaochen.beatles.pojo;

import lombok.ToString;

import javax.persistence.*;

/**
 * @author xiaochen
 */
@ToString
@Entity
@Table(name = "product")
public class Product {
    private int id;
    private String name;
    private double price;

    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    @Column(name = "id")
    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    @Column(name = "name")
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Column(name = "price")
    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }
}
2.数据持久层
package com.xiaochen.beatles.dao.impl;

import com.xiaochen.beatles.dao.ProductDao;
import com.xiaochen.beatles.pojo.Category;
import com.xiaochen.beatles.pojo.Product;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;

import java.util.ArrayList;
import java.util.List;

/**
 * @Author xiaochen
 * @Description
 * @Date 23:24 2020/3/25
 * @Param
 * @return
 **/
@Repository
public class ProductDaoImpl implements ProductDao {

    @Autowired
    SessionFactory sessionFactory;


    @Override
    public List getProduct(int id) {
        Session session = sessionFactory.openSession();
        session.beginTransaction();
        Product student = session.get(Product.class, id);
        Product student1 = session.get(Product.class, 2);
        Product student3 = session.get(Product.class, 3);
        Product student2 = session.get(Product.class, 4);
        Product student4 = session.get(Product.class, 5);
        Product student5 = session.get(Product.class, 6);
        List arrayList = new ArrayList();
        arrayList.add(student);
        arrayList.add(student1);
        arrayList.add(student2);
        arrayList.add(student3);
        arrayList.add(student4);
        arrayList.add(student5);
        return arrayList;
    }

    @Override
    public Product delProduct(int id) {
        Product product = new Product();
        product.setId(1);
        product.setName("1");
        Category category = new Category();
        category.setId(1);
        category.setName("1");
        return product;
    }

}
3.业务层
package com.xiaochen.beatles.service.impl;

import com.xiaochen.beatles.dao.ProductDao;
import com.xiaochen.beatles.pojo.Product;
import com.xiaochen.beatles.service.ProductService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

/**
 * @Author xiaochen
 * @Description
 * @Date 21:11 2020/3/25
 * @Param
 * @return
 **/

@Service
public class ProductServiceImpl implements ProductService {
    @Autowired
    ProductDao productDao;


    @Override
    public List getProduct(int id) {
        List list = productDao.getProduct(id);
        return list;

    }

    @Override
    public Product delProduct(int id) {
        Product product = productDao.delProduct(id);
        return product;
    }
}
4.控制访问层 (配置tomcat测试) //x.x.x.x:8080/showProduct
package com.xiaochen.beatles.acion;

import com.xiaochen.beatles.service.ProductService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;

import java.util.List;

@Controller
public class ProductAction {
    @Autowired
    private ProductService productService;

    private List product;

    public String show() {
        product = productService.getProduct(1);
        System.out.println("ProductAction: " + product);
        return "show";
    }

    public List getProduct() {
        return product;
    }

    public void setProduct(List product) {
        this.product = product;
    }
}
5.单元测试
package com.xiaochen.beatles.test;

import com.xiaochen.beatles.pojo.Category;
import com.xiaochen.beatles.pojo.Product;
import com.xiaochen.beatles.service.impl.ProductServiceImpl;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import javax.annotation.Resource;
import java.util.List;


@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:applicationContext.xml")
public class SpringTest {

    @Resource
    ProductServiceImpl productService;

    @Test
    public void getbeans() {
        Product p =new Product();
        p.setId(1);
        p.setName(" Product");
        Category category = new Category();
        category.setName("Category");
        category.setId(1);
        System.out.println(p);

    }

    @Test
    public void getPojo() {
        List product = productService.getProduct(1);
        for (Object o : product) {
            System.out.println(o);
        }


    }
}
LadyBirdsBeetles
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
idea中ssh框架整合
08-18
ssh框架如何在idea中整合
ssm框架理解ssh和ssm的对比
qq_35939148的博客
02-16 1407
转载来源于：http://blog.sina.com.cn/s/blog_9b86bcbf0102x761.html SSM框架理解  Spring Spring就像是整个项目中装配bean的大工厂，在配置文件中可以指定使用特定的参数去调用实体类的构造方法来实例化对象(可以通过属性、构造器、工厂方法进行注入)。 Spring的核心思想是IoC（控制反转），即不再需要程序员去显式地`new`一个...
Idea搭建整合SSH框架（Maven管理）
水中月
08-14 2515
1.开发环境： IntelliJ IDEA: 2016 Maven :3.0x Java 8 2.pom.xml project.build.sourceEncoding>UTF-8project.build.sourceEncoding> properties> dependency>
IntelliJ IDEA搭建SSH框架流程说明及配置文件
01-28
有详细的框架搭配流程说明，易懂易学，还有框架搭建所需的文档， 有问题欢迎探讨交流，接受指正，拒绝批评
IDEA整合Spring+Springmvc+mybatis+maven详细教程 实例下载
02-16
本教程将向您展示如何在IntelliJ IDEA（IDEA）中整合Spring、SpringMVC、MyBatis和Maven，构建一个完整的SSM（Spring、SpringMVC、MyBatis）项目。以下是对每个组件及其整合过程的详细说明： 1. **Spring框架**：...
java整合SSM框架的图文教程
08-28
本文将指导读者一步步搭建Java整合SSM框架的图文教程，包括搭建Maven项目、配置Maven环境、创建项目、修改Pom.xml文件、添加依赖项等步骤。 一、搭建Maven项目 在开始搭建SSM框架之前，我们需要先搭建一个Maven...
Java+maven+spring MVC+Spring+Hibernate整合
01-30
本项目标题为"Java+maven+spring MVC+Spring+Hibernate整合"，它旨在演示如何利用这些技术来创建一个完整的Web应用程序框架。下面将详细阐述其中涉及的技术及其整合过程。 首先，Maven是Apache软件基金会开发的一款...
mavenSSH+SSM
08-14
接下来，我们看看SSM框架： 1. **SpringMVC**：这是Spring框架的一个模块，也是一个MVC框架，与Struts类似，但更现代化。SpringMVC通过DispatcherServlet接收请求，然后通过HandlerMapping找到对应的Controller，...
基于springmvc+mybatis+spring+maven+mysql的微信小程序商城系统源码.zip
10-03
- **SSH**：SSH通常指的是Struts、Spring和Hibernate三个框架的组合，不过在这个上下文中没有明确提及，可能是误标或者表示Spring Security。 - **SpringBoot**：SpringBoot是Spring的简化版，旨在简化Spring应用...
JavaWeb_SSH框架入门，IntelliJ idea搭建Struts2的helloWorld
03-11
入门作业的源码，对于会的一点用都没有，只有还没咋接触过的人当作入门小源码用
整合ssm和ssh框架---spring-boot方式
06-11
这是一个spring-boot整合ssm和ssh框架所需要的pom依赖文件
ssm 和 ssh 整合（核心思路）
hello_world123456789的博客
05-30 344
ssm 需要的配置文件： web.xml Springmvc框架 src/springmvc.xml Mybatis框架 src/SqlMapConfig.xml mapper文件 src/mapper/xxx.Mapper.xml(名字最好跟dao层mapper接口一致，方便识别) Spring框架 src/applicationContext.xml 关于日志 log...
ssh和ssm框架整合步骤
Sunjin_shuai的博客
07-08 2346
servlet 和springmvc 被多个同时访问只产生一个对象. 是单例. 初心 EJB: enterprise javaBean 太笨重 Spring 功能用于替代EJB技术,主要用于管理对象以及对象见得依赖关系. 管理方式: 1.ICO/DI 控制翻转/依赖注入 IOC:从主动查找并调用自己所依赖的资源到被动接受spring注入的资源,成为控制反转
idea搭建ssh框架（超详细）
qq_43054104的博客
12-08 557
详见https://www.cnblogs.com/xinyijiu/p/10908237.html
SSM框架实战详细教程（三）IDEA+Maven搭建项目
Java朱老师博客
03-22 4139
        本章内容将搭建Maven，并且与IDEA关联，然后将上一篇中使用Eclipse中开发的普通Java Web项目改造成IDEA+Maven形式。         搭建Maven，并且与IDEA关联请查看Maven配置及eclipse和idea中使用文章。       &nbsp
jdbc了解及使用
时光
05-06 684
jdbc了解及使用
JDBC-文档
Cream336的博客
06-12 698
JDBC:连接数据库的桥梁 类库文件;
JDBC超详细笔记
最新发布
lingyued的博客
04-02 617
分享一份自己整理好的Java面试手册，还有一些面试题pdf。
SSM框架详解：SpringMVC+Spring+MyBatis多模块集成与Maven应用
SSM框架，全称为Spring MVC + Spring + MyBatis + Maven多模块的集成，是一种常见的企业级Java Web开发架构。该架构将这些成熟的技术组件结合在一起，提供高效、模块化的开发环境。 Spring MVC 是Spring框架的一...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值