使用idea集成SSJ框架

（一）三大框架简介

三大框架：

SSH: struts/struts2/SpringMVC+Spring+hibernate

一般使用的是SpringMVC+Spring+hibernate，因为Struts的bug太多，功能较少；Struts2学习成本较高

SSJ： SpringMVC+Spring+JPA
SSSDJ： SpringMVC+Spring+SpringDataJPA
SSM：Spring+Spring+MyBaties

（二） Spring集成JPA

（1）搭建项目环境

创建一个基于maven的web项目

注意需要在联网的情况下搭建，因为idea需要联网去网络上下载项目需要的资源，但如果在maven仓库中已经下载好了资源，则可以不用联网

修改配置文件，使用JDK1.8进行开发

  <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>
  </properties>

配置jar包

<dependencies>
    <!--Spring的Web的支持包-->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-web</artifactId>
      <version>4.2.5.RELEASE</version>
    </dependency>
    <!--Spring的MVC的支持包-->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-webmvc</artifactId>
      <version>4.2.5.RELEASE</version>
    </dependency>
    <!--Spring的JDBC包-->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-jdbc</artifactId>
      <version>4.2.5.RELEASE</version>
    </dependency>
    <!--Spring对于ORM的支持包(Spring和JPA的集成就在这个包中实现)-->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-orm</artifactId>
      <version>4.2.5.RELEASE</version>
    </dependency>
    <!--hibernate的核心包-->
    <dependency>
      <groupId>org.hibernate</groupId>
      <artifactId>hibernate-core</artifactId>
      <version>4.3.8.Final</version>
    </dependency>
    <!--hibernate对于jpa的支持包-->
    <dependency>
      <groupId>org.hibernate</groupId>
      <artifactId>hibernate-entitymanager</artifactId>
      <version>4.3.8.Final</version>
    </dependency>
    <!--mysql的驱动包(连数据库必需要加它)-->
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>5.1.6</version>
    </dependency>
    <!--引入dbcp连接池-->
    <dependency>
      <groupId>commons-dbcp</groupId>
      <artifactId>commons-dbcp</artifactId>
      <version>1.2.2</version>
    </dependency>
    <!--Spring的测试包-->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-test</artifactId>
      <version>4.2.5.RELEASE</version>
    </dependency>
    <!--要使用的切面包-->
    <dependency>
      <groupId>org.aspectj</groupId>
      <artifactId>aspectjweaver</artifactId>
      <version>1.8.9</version>
    </dependency>
    <!--SpringMVC返回JSON的支持包-->
    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-databind</artifactId>
      <version>2.6.5</version>
    </dependency>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.12</version>
      <scope>test</scope>
    </dependency>
  </dependencies>

搭建maven项目结构
创建spring的xml文件

下面我们就正式的集成SSJ框架

（2）配置jdbc.properties文件

新建一个jdbc.properties文件，并进行配置

jdbc.driverClassName=com.mysql.jdbc.Driver  /*jdbc.driverClassName这个可以自定义*/
jdbc.url=jdbc:mysql:///ssj                                    /*配置自定义的数据库*/
jdbc.username=root
jdbc.password=admin

在Spring的xml文件内，引入jdbc.properties文件

引入之前，需要先配置扫描contex内容

<!--  引入jdbc.properties文件   因为配置文件在resource文件下，所以必须加classpath:，否则找不到-->
<context:property-placeholder location="classpath:jdbc.properties"/>

配置DataSource

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

（3）配置EntityMangerFactory连接对象

alt+insert快键，可以快速弹出gernerate窗口，选择JPA，然后选择第二个
使用idea集成SSJ框架

![rmark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyMTM2MjUw,size_16,color_FFFFFF,t_70)
g.cn/2019031119285370.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyMTM2MjUw,size_16,color_FFFFFF,t_70)

	<bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
        <!--配置连接信息,此处的ref中的内容就是配置的DataSource中id-->
        <property name="dataSource" ref="dataSource"/>
        <!--配置包的扫描(Scan)机制,可以扫描到JPA的注解 -->
        <property name="packagesToScan" value="cn.lzj.domain" />
        <!--配置适配器 Spring+JPA(ORM规范) -> 配置hibernate来实现JPA-->
        <property name="jpaVendorAdapter">
            <bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter">
                <!--方言(确定数据库)-->
                <property name="databasePlatform" value="org.hibernate.dialect.MySQLDialect" />
                <!--建表策略  true:update -->
                <property name="generateDdl" value="true" />
                <!--支持SQL显示-->
                <property name="showSql" value="true" />
            </bean>
        </property>
    </bean>

此时可以验证一下，是否能获取这个EntityMangerFactory对象
创建一个产品domain,然后在测试类中，获取这个EntityMangerFactory对象，正常情况下，会在mysql下你设置的数据库中创建一个产品表，以下是我的一个简单测试

创建一个产品domain

@Entity
@Table(name = "product")
public class Product {

    @Id
    @GeneratedValue
    private Long id;

    private String name;
}

测试类中的部分核心代码：

	@Autowired
    private EntityManagerFactory factory;

    @Test
    public void test()throws Exception{
        System.out.println(factory);
    }

运行之后，在数据库中生成了一张产品表
使用idea集成SSJ框架

（4）配置dao层

在Spring的xml中配置包扫描，告诉Spring来扫描我这个dao层

<!--告诉Spring，扫描对应的包
	注：Spring和JPA的扫描，都只会扫描自己对应的注解
-->
 <context:component-scan base-package="cn.lzj.dao" />

搭建dao层

注意：
① 在实现类中配置@Repository，告诉Spring这是dao层
② 并注入EntityMangerFactory对象，然后实现接口的CRUD方法
③ 此时不能再使用@Autowired注入对象，必须使用@PersistenceContext持久化上下文注入EntityMangerFactory对象

常识：
① 事务是在service层开启（因为事务是一组同生共死的操作，三层中只有业务层才能满足同一组操作）
② 一次请求，就是一个线程，一个线程只需要一个EntityManger对象
③ @PersistenceContext会判断被标记的是什么对象，并去上下文中寻找（此处的上下文就是一次请求），如果没有需要的对象，会自动创建此对象，并将此对象放置在上下文中，保证一次请求中只有一个EntityManger对象。（备注：一个项目只需要一个EntityMangerFactory对象）

package cn.lzj.dao.impl;

import cn.lzj.dao.IProductDao;
import cn.lzj.domain.Product;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.PersistenceContext;
import java.util.List;

@Repository
public class ProductDaoImpl implements IProductDao {
    @PersistenceContext
    private EntityManager entityManager;
    @Override
    public void save(Product product) {
        entityManager.persist(product);
    }
    @Override
    public void update(Product product) {
        entityManager.merge(product);
    }
    @Override
    public void delete(Long id) {
        Product product = findOne(id);
        if(product!=null){
            entityManager.remove(product);
        }
    }
    @Override
    public Product findOne(Long id) {
        return entityManager.find(Product.class,id);
    }
    @Override
    public List<Product> findAll() {
        /* 使用JPQL查询数据 */
        String jpql = "select o from Product o";
        return entityManager.createQuery(jpql).getResultList();
    }
}

（5）配置service层

在Spring的xml中配置包扫描，扫描service层
在service层注入dao层
在Spring的xml中，配置对JPA的事务支持
选择第四个
配置tx头

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

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

配置事务对象，并开启事务支持

	<!--  准备事务对象 -->
    <bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
        <property name="entityManagerFactory" ref="entityManagerFactory"/>
    </bean>
    <!-- Spring对JPA的事务支持 -->
    <tx:annotation-driven transaction-manager="transactionManager" />

使用idea集成SSJ框架

在service层配置事务注解

package cn.lzj.service.impl;

import cn.lzj.dao.IProductDao;
import cn.lzj.domain.Product;
import cn.lzj.service.IProductService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

import java.util.List;

@Service
@Transactional
public class ProductServiceImpl implements IProductService {
    @Autowired
    private IProductDao productDao;
    @Override
    public void save(Product product) {
        productDao.save(product);
    }
    @Override
    public void update(Product product) {
        productDao.update(product);
    }
    @Override
    public void delete(Long id) {
        productDao.delete(id);
    }
    /**
     * readOnly = true:代表只读
     * 	添加之后，查询的性能会增加
     */
    @Override
    @Transactional(readOnly = true,propagation = Propagation.SUPPORTS)
    public Product findOne(Long id) {
        return productDao.findOne(id);
    }
    /**
     * propagation:事务传播机制
     *  Propagation.REQUIRED(必须的)：默认
     *      调用这个方法的时候如果已经有事务了,咱们这个事务被包含到里面去
     *      调用这个方法的时候没有事务,就应该新开一个事务
     *  Propagation.REQUIRES_NEW：不管访问我的方法有没有事务，我都只开一个单独的事物
     *  Propagation.NEVER(永不)：绝对不能出现事务(如果出现，我就报错)
     *  Propagation.SUPPORTS(支持):访问我如果有事务(支持)  如果没有事务(也支持)
     */
    @Override
    @Transactional(readOnly = true,propagation = Propagation.SUPPORTS)
    public List<Product> findAll() {
        return productDao.findAll();
    }
}

（三） Spring集成SpringMVC

（1）创建applicationContext-mvc.xml

（2）配置

1）配置Controller的包

前提需要配置context的头和mvc的头

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="
       http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
       http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc.xsd
">

2）配置mvc注解

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="
       http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
       http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc.xsd
">
    <!--扫描Congtroller包-->
    <context:component-scan base-package="cn.lzj.controller" />
    <!--SpringMVC的支持注解-->
    <mvc:annotation-driven/>
    <!--支持静态资源(因为代码使用RESTful风格spring就无法在访问静态资源)-->
    <mvc:default-servlet-handler/>
    <!--视图解析器-->
    <bean  class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/views/"/>
        <property name="suffix" value=".jsp"/>
    </bean>
        
</beans>

3）配置web.xml

注意修改xml的约束，因为2.4以下的版本不支持EL表达式

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd"
         id="WebApp_ID" version="3.1">

  <!--SpringMVC的POST请求的编码问题-->
  <filter>
    <filter-name>characterEncodingFilter</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>
    <init-param>
      <param-name>forceEncoding</param-name>
      <param-value>true</param-value>
    </init-param>
  </filter>
  <filter-mapping>
    <filter-name>characterEncodingFilter</filter-name>
    <url-pattern>/*</url-pattern>
  </filter-mapping>


  <!--配置监听器，会自动去启动Spring（读取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>

  <!--配置SpringMVC的核心控制器-->
  <servlet>
    <servlet-name>dispatcherServlet</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <!--获到SpringMVC的配置文件-->
    <init-param>
      <param-name>contextConfigLocation</param-name>
      <param-value>classpath:applicatioContext-mvc.xml</param-value>
    </init-param>
    <!-- 服务器启动的时候就开启SpringMVC-->
    <load-on-startup>1</load-on-startup>
  </servlet>

  <servlet-mapping>
    <servlet-name>dispatcherServlet</servlet-name>
    <!--这种 斜杠就符合RESTful风格-->
    <url-pattern>/</url-pattern>
  </servlet-mapping>

</web-app>