项目第一天 框架集成

一、使用到的技术

**spring SpringMVC SpringDateJpa shiro
	 EasyUI POI EasyPOI**

二、整个项目完成的功能

 **  1. 导入导出功能
	 2. 产品模块
	 3. 采购订单
	 4. 报表
	 5. 销售模块
   	 6. 邮件发送**

三、开始集成

3.1 整个项目结构

• common 用来放常用的类
• contoller 逻辑控制器
• domain 实体类包
• query 主要用来放查询类包
• repostory 以前的dao 数据类包
• servicer 业务层 有什么业务都放在这里

3.2 导包

这是整个项目要用到的相关包
 <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <org.springframework.version>4.2.5.RELEASE</org.springframework.version>
        <org.hibernate.version>4.3.8.Final</org.hibernate.version>
        <spring-data-jpa.version>1.9.0.RELEASE</spring-data-jpa.version>
        <com.fasterxml.jackson.version>2.5.0</com.fasterxml.jackson.version>
        <org.slf4j.version>1.6.1</org.slf4j.version>
    </properties>
    <dependencies>
        <!-- Spring的支持包 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>${org.springframework.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${org.springframework.version}</version>
        </dependency>
        <!-- 上下文支持包(帮我们集成:模板,邮件,任务调度...) -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context-support</artifactId>
            <version>${org.springframework.version}</version>
        </dependency>
        <!--事务包-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-tx</artifactId>
            <version>${org.springframework.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>${org.springframework.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-orm</artifactId>
            <version>${org.springframework.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aop</artifactId>
            <version>${org.springframework.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>${org.springframework.version}</version>
            <scope>test</scope>
        </dependency>
        <!-- 引入web前端的支持 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-web</artifactId>
            <version>${org.springframework.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>${org.springframework.version}</version>
        </dependency>
        <!-- SpringMVC上传需要用到io包-->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-io</artifactId>
            <version>1.3.2</version>
        </dependency>
        <!-- 文件上传用到的包 -->
        <dependency>
            <groupId>commons-fileupload</groupId>
            <artifactId>commons-fileupload</artifactId>
            <version>1.2.2</version>
        </dependency>
        <!-- SpringMVC的json支持包 -->
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-core</artifactId>
            <version>${com.fasterxml.jackson.version}</version>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-annotations</artifactId>
            <version>${com.fasterxml.jackson.version}</version>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>${com.fasterxml.jackson.version}</version>
        </dependency>
        <!-- hibernate的支持包 -->
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-core</artifactId>
            <version>${org.hibernate.version}</version>
        </dependency>
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-entitymanager</artifactId>
            <version>${org.hibernate.version}</version>
        </dependency>
        <!-- SpringDataJpa的支持包 -->
        <dependency>
            <groupId>org.springframework.data</groupId>
            <artifactId>spring-data-jpa</artifactId>
            <version>${spring-data-jpa.version}</version>
        </dependency>
        <!-- SpringDataJpa的扩展包 -->
        <dependency>
            <groupId>com.github.wenhao</groupId>
            <artifactId>jpa-spec</artifactId>
            <version>3.1.1</version>
            <!-- 把所有的依賴都去掉 -->
            <exclusions>
                <exclusion>
                    <groupId>*</groupId>
                    <artifactId>*</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <!--连接池(数据源)-->
        <dependency>
            <groupId>commons-dbcp</groupId>
            <artifactId>commons-dbcp</artifactId>
            <version>1.2.2</version>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.6</version>
        </dependency>
        <!--lang3:工具包 java.lang.-->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
            <version>3.5</version>
        </dependency>
        <!-- 测试包 -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>3.1.0</version>
            <!-- 这个scope 只能作用在编译和测试时，同时没有传递性。表示在运行的时候不添加此jar文件 -->
            <scope>provided</scope>
        </dependency>
        <!-- 日志文件 -->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>${org.slf4j.version}</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
            <version>${org.slf4j.version}</version>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.14</version>
        </dependency>
        <!-- 代码生成器模版技术  -->
        <dependency>
            <groupId>org.apache.velocity</groupId>
            <artifactId>velocity</artifactId>
            <version>1.6</version>
        </dependency>
        <!-- shiro(权限框架)的支持包 -->
        <dependency>
            <groupId>org.apache.shiro</groupId>
            <artifactId>shiro-all</artifactId>
            <version>1.4.0</version>
            <type>pom</type>
        </dependency>
        <!-- shiro与Spring的集成包 -->
        <dependency>
            <groupId>org.apache.shiro</groupId>
            <artifactId>shiro-spring</artifactId>
            <version>1.4.0</version>
        </dependency>
        <!-- poi(操作办公软件)支持的jar包 -->
        <dependency>
            <groupId>org.apache.poi</groupId>
            <artifactId>poi</artifactId>
            <version>3.11</version>
        </dependency>
        <dependency>
            <groupId>org.apache.poi</groupId>
            <artifactId>poi-ooxml</artifactId>
            <version>3.11</version>
        </dependency>
        <!-- 图片压缩功能 -->
        <!-- 缩略图 -->
        <dependency>
            <groupId>net.coobird</groupId>
            <artifactId>thumbnailator</artifactId>
            <version>0.4.6</version>
        </dependency>
        <!-- 定时调度 -->
        <dependency>
            <groupId>quartz</groupId>
            <artifactId>quartz</artifactId>
            <version>1.5.2</version>
        </dependency>
        <!-- 邮件支持 -->
        <dependency>
            <groupId>javax.mail</groupId>
            <artifactId>mail</artifactId>
            <version>1.4.1</version>
        </dependency>
    </dependencies>

    <build>
        <finalName>aisell</finalName>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.mortbay.jetty</groupId>
                <artifactId>jetty-maven-plugin</artifactId>
                <version>8.1.15.v20140411</version>
                <configuration>
                    <stopPort>9966</stopPort>
                    <stopKey>foo</stopKey>
                    <webAppConfig>
                        <contextPath>/</contextPath>
                    </webAppConfig>
                </configuration>
            </plugin>
        </plugins>
    </build>

3.3 集成spring环境

<beans xmlns="http://www.springframework.org/schema/beans"
       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/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
">

    <!--service-->
    <context:component-scan base-package="cn.com.aijiejieya.service" />
    <!--读取jdbc.properties-->
    <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>
    <!-- 配置EntityManagerFactory对象-->
    <bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
        <property name="dataSource" ref="dataSource"/>
        <!--扫描包 实体类-->
        <property name="packagesToScan" value="cn.com.aijiejieya.domain" />
        <!--知配器-->
        <property name="jpaVendorAdapter">
            <bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter">
                <property name="showSql" value="true" />
                <!--注意:现在已经有表了，不需要你去创建它-->
                <property name="generateDdl" value="false" />
                <property name="databasePlatform" value="org.hibernate.dialect.MySQLDialect" />
            </bean>
        </property>
    </bean>
    <!--配置一个事务对象-->
    <bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
        <property name="entityManagerFactory" ref="entityManagerFactory"/>
    </bean>
    <tx:annotation-driven />

    <!--SpringDataJpa的扫描 -->
    <jpa:repositories base-package="cn.com.aijiejieya.repository"
                      entity-manager-factory-ref="entityManagerFactory"
                      transaction-manager-ref="transactionManager" />

</beans>

3.4 集成SpringMVC环境

<?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
">
    <!--1.扫描 controller-->
    <context:component-scan base-package="cn.com.aijiejieya.controller" />
    <!--2.放行-->
    <mvc:default-servlet-handler />
    <!--3.注解-->
    <!-- Spring MVC 配置 -->
    <mvc:annotation-driven>
        </mvc:message-converters>
    </mvc:annotation-driven>
    <!--4.视图-->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/views/" />
        <property name="suffix" value=".jsp" />
    </bean>
    <!--5.上传-->
    <bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
        <property name="maxUploadSize">
            <value>10485760</value>
        </property>
    </bean>

</beans>

3.5 配置web.xml 文件

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


    <!--SpringMVC的配置和Spring的配置要单独读取，否则后面集成其它框架会出问题-->

    <!--运行与读取spring的配置 -->
    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:applicationContext.xml</param-value>
    </context-param>


    <!--配置mvc的核心控制器-->
    <servlet>
        <servlet-name>dispatchServlet</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <!--读取mvc配置-->
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:applicationContext-mvc.xml</param-value>
        </init-param>
        <!--tomcat启动用创建-->
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>dispatchServlet</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>

   
    <!--编码过滤-->
    <filter>
        <filter-name>encodingFilter</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>encodingFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>
</web-app>

四、开始写代码测试环境

4.1 domain 的编写

	private String username;
    private String password;
    private String email;
    private Integer age;

4.2 repository 的编写

我这里写的是父类 不写父类的话 employee直接继承下面的接口就行了

@NoRepositoryBean
public interface BaseRepository<T,ID extends Serializable>
        extends JpaRepository<T,ID>, JpaSpecificationExecutor<T> {
}

4.3 test测试 编写

package cn.com.aijiejieya.repository;

import cn.com.aijiejieya.domain.Employee;
import cn.com.aijiejieya.query.EmployeeQuery;
import com.github.wenhao.jpa.Specifications;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Pageable;
import org.springframework.data.domain.Sort;
import org.springframework.data.jpa.domain.Specification;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import javax.persistence.criteria.*;
import java.util.List;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class EmployeeRepositoryTest {

    @Autowired
    private EmployeeRepository employeeRepository;

    //Spring自动完成这个接口的实现(通过AOP)
    @Test
    public void test() throws Exception{

        System.out.println(employeeRepository);

        System.out.println(employeeRepository.getClass());
    }

    //添加
    @Test
    public void testSave() throws Exception{
        Employee employee = new Employee();
        employee.setUsername("ergou");
        employee.setPassword("1234");
        employee.setEmail("ergou@qq.com");
        employee.setAge(34);
        employeeRepository.save(employee);
    }
    //修改
    @Test
    public void testUpdate() throws Exception{
        Employee employee = new Employee();
        employee.setId(274L);
        employee.setUsername("ergoudage");
        employee.setPassword("1234");
        employee.setEmail("ergoudage@qq.com");
        employee.setAge(34);
        //save代表添加或者修改 会自动判断
        employeeRepository.save(employee);
    }
    //删除
    @Test
    public void testDelete() throws Exception{
        employeeRepository.delete(11L);
    }
    //查询一条数据
    @Test
    public void testFindOne() throws Exception{

        Employee employee = employeeRepository.findOne(274L);
        System.out.println(employee);
    }
    //查询所有数据
    @Test
    public void testFindAll() throws Exception{
        List<Employee> list = employeeRepository.findAll();
        list.forEach(e-> System.out.println(e));
    }

    //排序功能
    @Test
    public void testSort() throws Exception{
        /**
         * 创建排序对象
         *  参数一:排序的方式(升序/降序)
         *  参数二:排序的字段
         */
        Sort sort = new Sort(Sort.Direction.DESC,"age");
        //传一个排序对象(就可以排序了)
        List<Employee> list = employeeRepository.findAll(sort);
        list.forEach(e-> System.out.println(e));
    }

    //分页功能
    @Test
    public void testPage() throws Exception{
        /**
         * page:第几页(从0开始)
         * size:每页条数
         */
        Pageable pageable = new PageRequest(0,5);
        Page<Employee> page = employeeRepository.findAll(pageable);
        //总条数
        System.out.println(page.getTotalElements());
        //总页数
        System.out.println(page.getTotalPages());
        //当前页的数据
        //System.out.println(page.getContent());
        page.forEach(e-> System.out.println(e));
    }


    //分页,排序结合
    @Test
    public void testPageSort() throws Exception{
        //排序对象
        Sort sort = new Sort(Sort.Direction.DESC,"age");
        //分页对象(+排序)
        Pageable pageable = new PageRequest(0,10,sort);
        Page<Employee> page = employeeRepository.findAll(pageable);
        page.forEach(e-> System.out.println(e));
    }


    /**
     * 根据用户名进行查询
     * @throws Exception
     */
    @Test
    public void testMethodName01() throws Exception{
        Employee employee = employeeRepository.findByUsername("admin");
        System.out.println(employee);
    }
    /**
     * 根据用户名进行查询
     * @throws Exception
     */
    @Test
    public void testMethodName02() throws Exception{
        List<Employee> list = employeeRepository.findByUsernameLike("%1%");
        list.forEach(e-> System.out.println(e));
    }
    /**
     * 根据用户名与邮件进行查询
     * @throws Exception
     */
    @Test
    public void testMethodName03() throws Exception{
        List<Employee> list =
                employeeRepository.findByUsernameLikeAndEmailLike("%1%","%2%");
        list.forEach(e-> System.out.println(e));
    }


    @Test
    public void testQuery01() throws Exception{
        Employee employee = employeeRepository.query01("admin");
        System.out.println(employee);
    }
    @Test
    public void testQuery02() throws Exception{
        List<Employee> list = employeeRepository.query02("%1%");
        list.forEach(e-> System.out.println(e));
    }
    @Test
    public void testQuery03() throws Exception{
        List<Employee> list = employeeRepository.query03("%1%","%2%");
        list.forEach(e-> System.out.println(e));
    }
    @Test
    public void testQuerySql() throws Exception{
        List<Employee> list = employeeRepository.query04();
        list.forEach(e-> System.out.println(e));
    }

    /**
     * 最后可以解决咱们早上说的高级查询+分页
     * JpaSpecificationExecutor的基本使用 -> 主要是用于做查询
     * 功能要求:根据用户名做模糊查询
     * @throws Exception
     */
    @Test
    public void testJpaSpecificationExecutor02() throws Exception{
        /**
         * Specification:传一个规则进去
         */
        List<Employee> list = employeeRepository.findAll(new Specification<Employee>() {
            /**
             * @param root : 代表了可以查询和操作的实体对象的根，
             *                可以帮我们拿到对象的属性(我们通过它获到到username,email这些属性)
             * @param cq : 代表一个specific的顶层查询对象 => 不用
             *              包含查询的各个部分,比如select,from,where,group by ,order by 等
             *              简单理解 就是它提供 了查询ROOT的方法(where,select,having)
             *              如果你要做分组,排序就可以用到它(还可以连接多个条件)
             * @param cb : 用来构建CriteriaQuery的构建器对象(相当于条件或者说条件组合)
             *             主要判断关系（和这个字段是相等，大于，小于like等）
             * @return Predicate : 使以…为依据(最后返回的这个对象 : where username like ? and email like ? ...)
             */
            @Override
            public Predicate toPredicate(Root<Employee> root, CriteriaQuery<?> cq, CriteriaBuilder cb) {
                //1.通过根(root)拿到咱们的属性
                Path usernamePath = root.get("username");
                //2.通过cb进行条件的设置
                Predicate p = cb.like(usernamePath, "%1%");
                return p;
            }
        });
        list.forEach(e-> System.out.println(e));
    }

    /**
     * 功能要求:根据用户名与邮件做模糊查询
     */
    @Test
    public void testJpaSpecificationExecutor03() throws Exception{

        List<Employee> list = employeeRepository.findAll(new Specification<Employee>() {
            @Override
            public Predicate toPredicate(Root<Employee> root, CriteriaQuery<?> cq, CriteriaBuilder cb) {
                //1.拿到用户名和邮件的属性(Path)
                Path usernamePath = root.get("username");
                Path emailPath = root.get("email");
                //Path agePath = root.get("age");
                //2.设置条件(都用like)
                Predicate p1 = cb.like(usernamePath, "%1%");
                Predicate p2 = cb.like(emailPath, "%2%");
                //Predicate p3 = cb.gt(agePath, 20);

                //3.把两个条件结合起来
                Predicate p = cb.and(p1, p2);
                return p;
            }
        });
        list.forEach(e-> System.out.println(e));
    }

    //对查询的数据进行分页与排序
    @Test
    public void testJpaSpecificationExecutor04() throws Exception{
        //创建一个排序对象
        Sort sort = new Sort(Sort.Direction.DESC,"age");
        //创建一个分页对象
        Pageable pageable = new PageRequest(0,5,sort);

        Page<Employee> list = employeeRepository.findAll(new Specification<Employee>() {
            @Override
            public Predicate toPredicate(Root<Employee> root, CriteriaQuery<?> cq, CriteriaBuilder cb) {
                //1.拿到用户名和邮件的属性(Path)
                Path usernamePath = root.get("username");
                return cb.like(usernamePath,"%1%");
            }
        },pageable);
        list.forEach(e-> System.out.println(e));

    }


    /**
     * 功能要求:根据用户名做模糊查询
     */
    @Test
    public void testJpaSpec01() throws Exception{
        //1.创建查询规则
        Specification<Employee> spec = Specifications.<Employee>and()
                .like("username", "%1%")
                .build();
        //2.进行相应的查询
        List<Employee> list = employeeRepository.findAll(spec);

        list.forEach(e-> System.out.println(e));
    }
    /**
     * 功能要求:根据用户名与邮件做模糊查询
     */
    @Test
    public void testJpaSpec02() throws Exception{
        //创建查询规则
        Specification<Employee> spec = Specifications.<Employee>and()
                .like("username", "%1%")
                .like("email", "%2%")
                .gt("age",20)
                .build();
        //根据规则查询
        List<Employee> list = employeeRepository.findAll(spec);
        list.forEach(e-> System.out.println(e));
    }


    /**
     * 功能要求:查询+排序+分页
     */
    @Test
    public void testJpaSpec03() throws Exception{
        //排序
        Sort sort = new Sort(Sort.Direction.DESC,"age");
        //分页(从0开始)
        Pageable pageable = new PageRequest(0,5,sort);
        //创建查询规则
        Specification<Employee> spec = Specifications.<Employee>and()
                .like("username", "%1%")
                .build();
        //根据规则查询
        Page<Employee> list = employeeRepository.findAll(spec,pageable);
        list.forEach(e-> System.out.println(e));
    }


    /**
     * 功能要求:查询+排序+分页
     *  要查询什么? 分页每页多少条?当前第几页？　是否要排序？排序的话根据哪个字段，怎么排？　-> 都是用户决定
     */
    @Test
    public void testJpaSpec04() throws Exception{
        //以后这个对象是自动创建的(数据也是传过来)
        EmployeeQuery query = new EmployeeQuery();

        query.setOrderName("age");
        query.setOrderType(false);
        //排序
        Sort sort = query.createSort();
        //分页(从0开始)
        Pageable pageable = new PageRequest(query.getJpaPage(),query.getPageSize(),sort);
        //创建查询规则
        Specification<Employee> spec = query.createSpec();
        //根据规则查询
        Page<Employee> list = employeeRepository.findAll(spec,pageable);
        list.forEach(e-> System.out.println(e));
    }
}

采用的全注解的开发方式 居然已经开始写项目了 一些小的问题就不在这里写了
如果test测试运行成功 没有报错 那就证明我们这个项目框架集成完成了 后面就开发就是写代码的事情了