SpringMVC之JPA关于Specification复杂查询、 Example实例查询及QueryDSL查询

关于JPA与SpringMVC的整合相关配置

《！----------------------------------------applicationContext-jpa---------------------------------》

<?xml version="1.0" encoding="UTF-8"?>
<beans
xmlns="http://www.springframework.org/schema/beans"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:tx="http://www.springframework.org/schema/tx"
xmlns:jpa="http://www.springframework.org/schema/data/jpa"
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/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
http://www.springframework.org/schema/data/jpa
http://www.springframework.org/schema/data/jpa/spring-jpa.xsd">
    <!-- 1.引入公共配置文件 db.properties-->
    <context:property-placeholder location="classpath:db.properties"/>
    <!--2.配置数据源（druid）-->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource" destroy-method="close">
        <!-- 数据库基本信息配置 -->
        <property name="dbType" value="mysql"></property>
        <property name="driverClassName" value="${dataSource.driverClassName}"></property>
        <property name="url"      value="${dataSource.url}"></property>
        <property name="username"          value="${dataSource.username}"></property>
        <property name="password"      value="${dataSource.password}"></property>
              <property name="filters" value="${druid.filters}" />
        <!-- 最大并发连接数 -->
        <property name="maxActive" value="${druid.maxActive}" />
        <!-- 初始化连接数量 -->
        <property name="initialSize" value="${druid.initialSize}" />
        <!-- 配置获取连接等待超时的时间 -->
        <property name="maxWait" value="${druid.maxWait}" />
        <!-- 最小空闲连接数 -->
        <property name="minIdle" value="${druid.minIdle}" />
        <!-- 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒 -->
        <property name="timeBetweenEvictionRunsMillis" value="${druid.timeBetweenEvictionRunsMillis}" />
        <!-- 配置一个连接在池中最小生存的时间，单位是毫秒 -->
        <property name="minEvictableIdleTimeMillis" value="${druid.minEvictableIdleTimeMillis}" />
        <property name="validationQuery" value="SELECT 1" />
        <property name="testWhileIdle" value="${druid.testWhileIdle}" />
        <property name="testOnBorrow" value="${druid.testOnBorrow}" />
        <property name="testOnReturn" value="${druid.testOnReturn}" />
        <property name="maxOpenPreparedStatements" value="${druid.maxOpenPreparedStatements}" />
        <!-- 打开removeAbandoned功能 -->
        <property name="removeAbandoned" value="${druid.removeAbandoned}" />
        <!-- 1800秒，也就是30分钟 -->
        <property name="removeAbandonedTimeout" value="${druid.removeAbandonedTimeout}" />
        <!-- 关闭abanded连接时输出错误日志 -->
        <property name="logAbandoned" value="${druid.logAbandoned}" />
    </bean>
    
    <!--3.配置JPA entityManagerFactory-->
    <!-- 对“实体管理器”解释：我们知道原生的jpa的配置信息是必须放在META-INF目录下面的，并且名字必须叫做persistence.xml，
    这个叫做persistence-unit，就叫做持久化单元，放在这下面我们感觉不方便，不好，于是Spring提供了 org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean这样一个类，
    可以让你的随心所欲的起这个配置文件的名字，也可以随心所欲的修改这个文件的位置，只需要在这里指向这个位置就行。然而更加方便的做法是，直接把配置信息就写在这里更好，于是就有了这实体管理器这个bean。
    使用 <property name="packagesToScan" value="your entity package" /> !-->
    <!--定义实体的工厂bean-->
    <bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
        <property name="dataSource" ref="dataSource"/>
        <!--实体类位置-->
        <property name="packagesToScan" value="com.demo.entity"/>
        <!--持久化单元名-->
        <property name="persistenceUnitName" value="TestJPA" />
        <!--JPA提供者-->
        <property name="persistenceProviderClass" value="org.hibernate.ejb.HibernatePersistence"/>
        <!--JPA属性-->
        <property name="jpaProperties">
            <props>
                <!--配置方言-->
                <prop key="hibernate.dialect" >${hibernate.dialect}</prop>    
                <!--激活查询日志功能-->            
                <prop key="hibernate.show_sql">${hibernate.show_sql}</prop>
                <!--优雅地输出Sql-->
                 <prop key="hibernate.format_sql">${hibernate.format_sql}</prop>
                <prop key="hibernate.hbm2ddl.auto">${hibernate.hbm2ddl.auto}</prop>
                <!--添加一条解释型标注-->
                <prop key="hibernate.use_sql_comments">${hibernate.use_sql_comments}</prop>
                <prop key="hibernate.max_fetch_depth">2</prop>
            </props>
        </property>
    </bean>

    <!--第三步-->
    <!--定义事务管理器-->
    <bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
        <property name="dataSource" ref="dataSource"/>
        <property name="entityManagerFactory" ref="entityManagerFactory"/>
    </bean>

    <!--第四步-->
    <!--定义repository接口的存放目录-->
    <!--定义接口实现的后缀，通常用Impl-->
    <!--定义实体工厂的引用-->
    <!--定义事务管理器的引用-->
    <jpa:repositories base-package="com.demo.dao"
                      repository-impl-postfix="Impl"
                      entity-manager-factory-ref="entityManagerFactory"
                      transaction-manager-ref="transactionManager"/>

    <!--第五步-->
    <!--声明采用注解的方式申明事务-->
    <tx:annotation-driven transaction-manager="transactionManager"/>
</beans>

 

<!--------------------------------------------applicationContext-core------------------------------------->

<?xml version="1.0" encoding="UTF-8"?>
<beans
xmlns="http://www.springframework.org/schema/beans"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:context="http://www.springframework.org/schema/context"
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/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">

    <!-- 配置自动扫描的包 -->
    <context:component-scan base-package="com.demo.service">
        <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
         <context:exclude-filter type="annotation" expression="org.springframework.web.bind.annotation.ControllerAdvice"/>
    </context:component-scan>

    <!-- 启动AOP切面自动代理 -->
    <aop:aspectj-autoproxy proxy-target-class="true"/>
    
</beans>

 

<!--------------------------------------------db.properties-------------------------------------------->

dataSource.driverClassName=com.mysql.jdbc.Driver
dataSource.url=jdbc:mysql://localhost:3306/demo?useUnicode=true&characterEncoding=UTF-8&characterSetResults=UTF-8&&useSSL=false
dataSource.username=root
dataSource.password=gzkahjl
#druid start
druid.filters=stat
druid.maxActive=20
druid.initialSize=1
druid.maxWait=60000
druid.minIdle=10
druid.timeBetweenEvictionRunsMillis=60000
druid.minEvictableIdleTimeMillis=300000
druid.testWhileIdle=true
druid.testOnBorrow=false
druid.testOnReturn=false
druid.maxOpenPreparedStatements=20
druid.removeAbandoned=true
druid.removeAbandonedTimeout=1800
druid.logAbandoned=true

hibernate.connection.pool_size=1
hibernate.dialect=org.hibernate.dialect.MySQL5InnoDBDialect
#hibernate.current_session_context_class=thread
#hibernate.current_session_context_class=org.springframework.orm.hibernate5.SpringSessionContext
hibernate.cache.provider_class=org.hibernate.cache.internal.NoCacheProvider
hibernate.show_sql=true
hibernate.format_sql=true
hibernate.hbm2ddl.auto=update
hibernate.use_sql_comments=false

<!------------------------------------------相关entity类------------------------------------》

TUser类

@Entity
@Table(name = "t_user", schema = "demo", catalog = "")
public class TUser {
    private int id;
    private String name;
    private String password;
    private int deptId;
    
    @Id
    @GeneratedValue(strategy = IDENTITY)
    @Column(name = "id", unique = true, nullable = false)
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getPassword() {
        return password;
    }
    public void setPassword(String password) {
        this.password = password;
    }
    public int getDeptId() {
        return deptId;
    }
    public void setDeptId(int deptId) {
        this.deptId = deptId;
    }
   
}

TDepartment类

@Entity
@Table(name = "t_dept", schema = "demo", catalog = "")
public class TDepartment {

    private int deptId;
    private String departmentName;
    
    @Id
    @GeneratedValue(strategy = IDENTITY)
    @Column(name = "deptId", unique = true, nullable = false)
    public int getDeptId() {
        return deptId;
    }
    public void setDeptId(int deptId) {
        this.deptId = deptId;
    }
    public String getDepartmentName() {
        return departmentName;
    }
    public void setDepartmentName(String departmentName) {
        this.departmentName = departmentName;
    }
   
}

相关接口：

@NoRepositoryBean
public class BaseRepository {

    @PersistenceContext(unitName = "TestJPA")
    protected EntityManager em;

}

//User表示该Repository与实体User关联,主键类型为Integer
@Repository
public interface UserRepository extends PagingAndSortingRepository<TUser, Integer>,JpaRepository<TUser, Integer>, JpaSpecificationExecutor<TUser> {

    /**
     * CrudRepository:提供基本CRUD操作
     * <S extends T> S save(S entity); <S extends T>
     * Iterable<S> save(Iterable<S> entities);
     * void delete(ID id); void delete(T entity);
     * void delete(Iterable<? extends T> entities);
     * void deleteAll(); T
     * findOne(ID id);
     * Iterable<T> findAll();
     * Iterable<T> findAll(Iterable<ID> ids);
     * boolean exists(ID id);
     * long count();
     */

    /**
     * PagingAndSortingRepository:提供分页和排序功能    
     * Iterable<T> findAll(Sort sort);
     * Page<T> findAll(Pageable pageable);
     * Page:
            int getTotalPages();
            long getTotalElements();
     */
    
    /**
      *JpaSpecificationExecutor 动态查询接口：
     *T findOne(Specification<T> spec);
     *List<T> findAll(Specification<T> spec);
     *Page<T> findAll(Specification<T> spec, Pageable pageable);
     *List<T> findAll(Specification<T> spec, Sort sort);
     *long count(Specification<T> spec);
     */
}

 

public interface TDepartmentRepository extends CrudRepository<TDepartment,Integer> ,QueryDslPredicateExecutor<TDepartment>,TDepartmentRepositoryCustom{

}

/**
 * QueryDSL自定义复杂查询
 *
 * @author gzkahjl
 *
 */
public interface TDepartmentRepositoryCustom {
    /**
     * 关联查询示例,查询出部门和对应的用户
     *
     * @param predicate 查询条件
     * @return 查询实体
     */
    public List<Tuple> findDeptAndUser(Predicate predicate);
    
    /**
     * 自定义查询并封装到DTO
     */
    public QueryResults<TUserDeptDTO> findUserDeptDTO(Predicate predicate, Pageable pageable);

    /**
     * 关联查询示例,分页查询出部门和对应的用户
     *
     * @param predicate 查询条件
     * @return 查询实体
     */
    public QueryResults<Tuple> findDeptAndUserPage(Predicate predicate, Pageable pageable);
}

//自定义Repository

//这里的名字必须是TDepartmentRepositoryImp，否则无法注入成功。

//参考：https://blog.csdn.net/qq_36722039/article/details/81148189

@Repository
public class TDepartmentRepositoryImpl extends BaseRepository implements TDepartmentRepositoryCustom {

    /**删除
     *queryFactory.delete(QTDepartment.tDepartment).where(QTDepartment.tDepartment.deptId.eq(3)).execute();
     */
    @Override
    public List<Tuple> findDeptAndUser(Predicate predicate) {
        // TODO Auto-generated method stub
        JPAQueryFactory queryFactory = new JPAQueryFactory(em);

        // 典型的左外连接
        JPAQuery<Tuple> jpaQuery = queryFactory.select(QTDepartment.tDepartment, QTUser.tUser)
                .from(QTDepartment.tDepartment).leftJoin(QTUser.tUser)
                .on(QTUser.tUser.id.eq(QTDepartment.tDepartment.deptId));
        jpaQuery.where(predicate);
        return jpaQuery.fetch();
    }
    
    @Override
    public QueryResults<TUserDeptDTO> findUserDeptDTO(Predicate predicate, Pageable pageable) {
        // TODO Auto-generated method stub
        JPAQueryFactory queryFactory = new JPAQueryFactory(em);
        JPAQuery<TUserDeptDTO> jpaQuery = queryFactory.select((Projections.constructor(TUserDeptDTO.class,QTDepartment.tDepartment.deptId,QTDepartment.tDepartment.departmentName,QTUser.tUser.name)))
                .from(QTDepartment.tDepartment).leftJoin(QTUser.tUser)
                .on(QTUser.tUser.id.eq(QTDepartment.tDepartment.deptId));
        jpaQuery.where(predicate)
        .offset(pageable.getOffset())
        .limit(pageable.getPageSize());
        return jpaQuery.fetchResults();
    }

    @Override
    public QueryResults<Tuple> findDeptAndUserPage(Predicate predicate, Pageable pageable) {
        // TODO Auto-generated method stub
        //分页带条件查询
        JPAQueryFactory queryFactory = new JPAQueryFactory(em);
        JPAQuery<Tuple> jpaQuery = queryFactory.select(QTDepartment.tDepartment, QTUser.tUser)
                .from(QTDepartment.tDepartment).leftJoin(QTUser.tUser)
                .on(QTUser.tUser.id.eq(QTDepartment.tDepartment.deptId))
                .where(predicate)
                .offset(pageable.getOffset())
                .limit(pageable.getPageSize());
        //分页结果
        return jpaQuery.fetchResults();
    }

}

//测试

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = { "classpath:applicationContext-core.xml", "classpath:applicationContext-jpa.xml" })
@Transactional
public class TestMyDao {

   ..................

    /**
     * JPA常用查询
     */
    @Test
    public void test1() {
        Iterable<TUser> userList = userDao.findAll();
        userList.forEach((e) -> {
            System.out.println(e.getId() + "----" + e.getName());
        });
        /*
         * TUser tUser = null; List<TUser> list = new ArrayList<TUser>(0); for (int i =
         * 0; i < 10; i++) { tUser = new TUser(); tUser.setName("gzkahjl"+i);
         * list.add(tUser); } userDao.save(list);
         */
    }

    /**
     * Specification复杂查询 使用JpaSpecificationExecutor高级查询 分页查询
     */
    @Test
    public void test2() {
        Sort sort = new Sort(Sort.Direction.DESC, "id");
        Iterable<TUser> findAll = userDao.findAll(new Specification<TUser>() {

            @Override
            public Predicate toPredicate(Root<TUser> root, CriteriaQuery<?> query, CriteriaBuilder cb) {
                // TODO Auto-generated method stub
                List<Predicate> list = new ArrayList<Predicate>(0);
                Predicate c1 = cb.like(root.get("name").as(String.class), "%gzkahjl%");
                list.add(c1);
                Predicate[] p = new Predicate[list.size()];
                // 4.CriteriaBuilder的and 函数组装 查询条件数组
                return cb.and(list.toArray(p));
            }
        }, new PageRequest(0, 5, sort));

        findAll.forEach((e) -> {
            System.out.println(e.getId() + "----" + e.getName());
        });
    }

 

    /**
     * 学习：https://blog.csdn.net/qq_30054997/article/details/79420141 Example实例查询
     * 创建一个ExampleMatcher对象，最后再用Example的of方法构造相应的Example对象并传递给相关查询方法
     */
    @Test
    public void test3() {
        TUser user = new TUser();
        user.setName("gzk");
        ExampleMatcher matcher = ExampleMatcher.matching()
                // .withStringMatcher(StringMatcher.CONTAINING) //改变默认字符串匹配方式：即%{name}%
                // .withIncludeNullValues() //改变“Null值处理方式”：包括
                .withMatcher("name", GenericPropertyMatchers.contains()) // 姓名采用“开始匹配”的方式查询,即{name}%
                // .withIgnorePaths("int"); //忽略属性：是否关注。因为是基本类型，需要忽略掉
                .withIgnorePaths("id");
        Example<TUser> example = Example.of(user, matcher); // Example根据域对象和配置创建一个新的ExampleMatcher
        List<TUser> findAll = userDao.findAll(example); // 忽略其他属性
        findAll.forEach((e) -> {
            System.out.println(e.getId() + "----" + e.getName());
        });
    }

 

/**
     * https://www.jianshu.com/p/69dcb1b85bbb QueryDsl查询
     */
    @Test
    public void test4() {
        // 简单查询
        QTDepartment tdepartment = QTDepartment.tDepartment;
        Iterable<TDepartment> findAll = deptDao.findAll(tdepartment.departmentName.like("%技术%"));
        findAll.forEach((e) -> {
            System.out.println(e.getDeptId() + "----" + e.getDepartmentName());
        });

        // 别一种查询
        BooleanBuilder builder = new BooleanBuilder();
        builder.and(tdepartment.departmentName.like("%商务%"));
        Iterable<TDepartment> findAll2 = deptDao.findAll(builder);
        findAll2.forEach((e) -> {
            System.out.println(e.getDeptId() + "----" + e.getDepartmentName());
        });

        // 带条件排序查询
        OrderSpecifier<Integer> order = new OrderSpecifier<Integer>(com.querydsl.core.types.Order.DESC,
                tdepartment.deptId);
        deptDao.findAll(tdepartment.departmentName.like("%技术%"), order);

    }

    @Test
    public void test5() {
        // 查询并将结果封装至dto中
        QueryResults<TUserDeptDTO> findUserDeptDTO = deptDao.findUserDeptDTO(null, new PageRequest(0, 5));
        findUserDeptDTO.getResults().forEach((e)->{
            System.out.println(e.getDeptId() + "----" + e.getDepartmentName());
        });

        QTDepartment qDept = QTDepartment.tDepartment;
        QTUser qtUser = QTUser.tUser;
        BooleanExpression predicate = qDept.departmentName.like("%技术%");
        List<Tuple> result = deptDao.findDeptAndUser(predicate);
        for (Tuple row : result) {
            System.out.println("qtDept:" + row.get(qDept));
            System.out.println("qtUser:" + row.get(qtUser));
        }
        System.out.println(result);
    }

 

    @Test
    public void test6() {
        QTDepartment qDept = QTDepartment.tDepartment;
        QTUser qUser = QTUser.tUser;
        BooleanExpression predicate = qDept.departmentName.like("%技术%");
        QueryResults<Tuple> result = deptDao.findDeptAndUserPage(predicate, new PageRequest(0,5));
         //结果取出
        for (Tuple row : result.getResults()) {
            System.out.println("qtDept:"+row.get(qDept).getDepartmentName());
            System.out.println("qtUser:"+row.get(qUser));
            System.out.println("--------------------");
        }
        //取出count查询总数
        System.out.println(result.getTotal());
    }

}

<!---------------------------------------------My POM --------------------------------------------------->

<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.kdw</groupId>
  <artifactId>demo</artifactId>
  <packaging>war</packaging>
  <version>0.0.1-SNAPSHOT</version>
  <name>demo Maven Webapp</name>
  <url>http://maven.apache.org</url>
 <properties>
    <jdk.version>1.8</jdk.version>
      <spring.version>4.3.13.RELEASE</spring.version>
      <aspectj.version>1.8.13</aspectj.version>
      
      <gson.version>2.8.5</gson.version>
      <joda.version>2.3</joda.version>
      <jsp.version>2.3.1</jsp.version>
    <servlet.version>3.1.0</servlet.version>
    <slf4j.version>1.7.25</slf4j.version>
    <logback.version>1.1.2</logback.version>
    
      <spring-data-jpa.version>1.11.9.RELEASE</spring-data-jpa.version>
    <hibernate.version>5.1.0.Final</hibernate.version>
     <querydsl.version>4.1.4</querydsl.version>
    <mysql.version>5.1.38</mysql.version>
    <druid.version>1.1.10</druid.version>
    <junit.version>4.12</junit.version>

    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  </properties>
 
 
  <dependencies>
 
      <!-- Spring Framework -->
      <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>${spring.version}</version>
    </dependency>
    
    <!-- ============================Spring ORM=============================== -->
    <!-- Spring ORM -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-orm</artifactId>
        <version>${spring.version}</version>
    </dependency>    
    <!-- AOP -->
    <dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjrt</artifactId>
        <version>${aspectj.version}</version>
    </dependency>
    <dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjweaver</artifactId>
        <version>${aspectj.version}</version>
    </dependency>
    
        <!-- Hibernate JPA -->
    <dependency>
        <groupId>org.springframework.data</groupId>
        <artifactId>spring-data-jpa</artifactId>
        <version>${spring-data-jpa.version}</version>
    </dependency>
    
   <!-- Hibernate Framework-->
      <dependency>
        <groupId>org.hibernate</groupId>
        <artifactId>hibernate-core</artifactId>
        <version>${hibernate.version}</version>
    </dependency>
    <dependency>
        <groupId>org.hibernate</groupId>
        <artifactId>hibernate-c3p0</artifactId>
        <version>${hibernate.version}</version>
    </dependency>
    
    <dependency>
        <groupId>org.hibernate</groupId>
        <artifactId>hibernate-entitymanager</artifactId>
        <version>${hibernate.version}</version>
    </dependency>
    
     <!--query dsl-->
    <dependency>
      <groupId>com.querydsl</groupId>
      <artifactId>querydsl-jpa</artifactId>
      <version>${querydsl.version}</version>
    </dependency>
    <dependency>
      <groupId>com.querydsl</groupId>
      <artifactId>querydsl-apt</artifactId>
      <version>${querydsl.version}</version>
      <scope>provided</scope>
    </dependency>
    <!--query dsl end-->
    
    <!-- mysql connector-->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>${mysql.version}</version>
    </dependency>
    
    <!-- 连接池 -->        
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>druid</artifactId>
        <version>${druid.version}</version>
    </dependency>
      <!-- ============================Spring Web=============================== -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-webmvc</artifactId>
        <version>${spring.version}</version>
    </dependency>

    <!-- ============================ Web 3.1 =============================== -->
    <!-- GSON -->
    <dependency>
    <groupId>com.google.code.gson</groupId>
    <artifactId>gson</artifactId>
    <version>${gson.version}</version>
    </dependency>
    <!-- Joda Time Library -->
    <dependency>
        <groupId>joda-time</groupId>
        <artifactId>joda-time</artifactId>
        <version>${joda.version}</version>
    </dependency>
    <dependency>
        <groupId>javax.servlet.jsp</groupId>
        <artifactId>javax.servlet.jsp-api</artifactId>
        <version>${jsp.version}</version>
        <scope>provided</scope>
    </dependency>
    <dependency>
        <groupId>javax.servlet</groupId>
        <artifactId>javax.servlet-api</artifactId>
        <version>${servlet.version}</version>
        <scope>provided</scope>
    </dependency>
    <!-- log4j -->
    <dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>slf4j-api</artifactId>
        <version>${slf4j.version}</version>
     </dependency>
    <dependency>
        <groupId>ch.qos.logback</groupId>
        <artifactId>logback-access</artifactId>
        <version>${logback.version}</version>
    </dependency>
    <dependency>
        <groupId>ch.qos.logback</groupId>
        <artifactId>logback-core</artifactId>
        <version>${logback.version}</version>
    </dependency>
    <dependency>
        <groupId>ch.qos.logback</groupId>
        <artifactId>logback-classic</artifactId>
        <version>${logback.version}</version>
    </dependency>
    <!-- ============================Spring Test=============================== -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-test</artifactId>
        <version>${spring.version}</version>
        <scope>test</scope>
    </dependency>
    
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>${junit.version}</version>
      <scope>test</scope>
    </dependency>
  </dependencies>

  <build>
        <finalName>ssh-demo</finalName>
      <plugins>
      <!--该插件可以生成querysdl需要的查询对象，执行mvn compile即可-->
      <plugin>
        <groupId>com.mysema.maven</groupId>
        <artifactId>apt-maven-plugin</artifactId>
        <version>1.1.3</version>
        <executions>
          <execution>
            <goals>
              <goal>process</goal>
            </goals>
            <configuration>
              <outputDirectory>target/generated-sources/java</outputDirectory>
              <processor>com.querydsl.apt.jpa.JPAAnnotationProcessor</processor>
            </configuration>
          </execution>
        </executions>
      </plugin>
      
          <plugin>
              <groupId>org.apache.maven.plugins</groupId>
              <artifactId>maven-compiler-plugin</artifactId>
              <version>3.1</version>
              <configuration>
                  <source>${jdk.version}</source>
                  <target>${jdk.version}</target>
                  <encoding>${project.build.sourceEncoding}</encoding>
                  <showWarnings>true</showWarnings>
              </configuration>
          </plugin>
          <plugin>
            <groupId>org.apache.tomcat.maven</groupId>
            <artifactId>tomcat7-maven-plugin</artifactId>
            <version>2.2</version>
            <configuration>
                <charset>${project.build.sourceEncoding}</charset>
                <uriEncoding>${project.build.sourceEncoding}</uriEncoding>
                <port>8080</port>
            </configuration>
        </plugin>
        <!-- 配置打包时跳过测试  -->
         <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-surefire-plugin</artifactId>
                <version>2.12.4</version>
         </plugin>
      </plugins>
  </build>
</project>