智能商贸项目-基本框架

智能商贸项目-基本框架

一、后台支持

（一）Dao层

• 父类

import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
import org.springframework.data.repository.NoRepositoryBean;

import java.io.Serializable;

/**
 * @NoRepositoryBean:让Spring管理的时候不要为这个接口创建实现
 * @param 
 * @param 
 */
@NoRepositoryBean
public interface BaseRepository<T,ID extends Serializable> extends JpaRepository<T,ID>,JpaSpecificationExecutor {
     
}

• 子类

/*在用来的基础上，必需改成继承父类BaseRepsitory*/
public interface EmployeeRepository extends BaseRepository<Employee,Long>{
     }

（二）Service层

1.创建父接口

import com.lty.aisell.query.BaseQuery;
import org.springframework.data.domain.Page;

import java.io.Serializable;
import java.util.List;

public interface IBaseService<T,ID extends Serializable> {
     
    //添加或者修改
    void save(T t);
    //删除
    /**
     * 联合主键
     * 在JPA中，要求主键必需实现Serializable接口
     * @param id
     */
    void delete(ID id);
    //根据ID查询一条数据
    T findOne(ID id);
    //查询所有
    List<T> findAll();
    //根据查询条件(query对象)查询对应的数据
    List<T> queryAll(BaseQuery query);
    //根据查询条件(query对象)查询对应的分页排序数据
    Page<T> queryPage(BaseQuery query);
    //根据JPQL进行查询

    /**
     * @param jpql : select o from ... where name like ?1 and age > ?2
     * @param params : 参数(类型与数量不确定)
     * @return
     */
    List<Object> queryByJpql(String jpql,Object...params);
}

2.创建父接口的实现类

import com.lty.aisell.query.BaseQuery;
import com.lty.aisell.repository.BaseRepository;
import com.lty.aisell.service.IBaseService;
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.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import javax.persistence.Query;
import java.io.Serializable;
import java.util.List;

/**
 * 抽象的类是无法创建对象的(只能做父类)
 * 实现类无法确定接口中泛型的类型
 * @param 
 * @param 
 */
@Transactional(readOnly = true,propagation = Propagation.SUPPORTS)
public abstract class BaseServiceImpl<T,ID extends Serializable> implements IBaseService<T,ID> {
     
    /**
     *  Spring会把相应的BaseRepository实现对象注入进来(注:它有很多子接口)
     *      BaseRepository -> EmployeeRepository
     *                        DepartmentRepository
     *                        ...
     *  确定注入的是哪一个对象(使用的时候确定)
     *      EmployeeServiceImpl extends BaseServiceImpl
     *          new EmployeeServiceImpl().save();
     */
    @Autowired
    private BaseRepository<T,ID> baseRepository;
    //自动从当前上下文中获取EntityManager对象
    @PersistenceContext
    EntityManager entityManager;

    @Override
    @Transactional
    public void save(T t) {
     
        baseRepository.save(t);
    }

    @Override
    @Transactional
    public void delete(ID id) {
     
        baseRepository.delete(id);
    }

    @Override
    public T findOne(ID id) {
     
        return baseRepository.findOne(id);
    }

    @Override
    public List<T> findAll() {
     
        return baseRepository.findAll();
    }

    @Override
    public List<T> queryAll(BaseQuery query) {
     
        //拿到查询规则
        Specification spec = query.createSpec();
        //根据规则进行查询
        return baseRepository.findAll(spec);
    }

    @Override
    public Page<T> queryPage(BaseQuery query) {
     
        //拿到排序对象
        Sort sort = query.createSort();
        //拿到分页对象
        Pageable pageable = new PageRequest(query.getJPACurrentPage(),query.getPageSize(),sort);
        //拿到查询规则
        Specification spec = query.createSpec();
        //根据规则进行查询
        return baseRepository.findAll(spec,pageable);
    }

    /**
     * 执行jpql，就必需要EntityManager对象
     */
    @Override
    public List<Object> queryByJpql(String jpql, Object... params) {
     
        //获取query对象
        Query query = entityManager.createQuery(jpql);
        //循环params参数(对应的是?的值)，把参数放进去
        for (int i = 0; i < params.length ;i++){
     
            query.setParameter(i+1,params[i]);//这里设置值是从1开始的
        }
        //获取数据
        return query.getResultList();
    }
}

3.创建子接口

import com.lty.aisell.domain.Employee;

public interface IEmployeeService extends IBaseService<Employee,Long> {
     
    //注：在开发中，业务后期是有很多功能的(不只是我们最简单的CRUD)
}

4.创建子接口的实现类

import com.lty.aisell.domain.Employee;
import com.lty.aisell.service.IEmployeeService;
import org.springframework.stereotype.Service;

@Service
public class EmployeeServiceImpl extends BaseServiceImpl<Employee,Long> implements IEmployeeService {
     }

二、集成SpringMVC

1.配置applicationContext-mvc.xml

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

    
    <context:component-scan base-package="com.lty.aisell.controller">context:component-scan>

    
    <mvc:annotation-driven>mvc:annotation-driven>

    
    <mvc:default-servlet-handler>mvc:default-servlet-handler>

    
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/views/">property>
        <property name="suffix" value=".jsp">property>
    bean>

    
    <bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
        <property name="maxUploadSize">
            <value>10485760value>
        property>
    bean>
beans>

2.配置web.xml

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

  
  <listener>
    <listener-class>org.springframework.web.context.ContextLoaderListenerlistener-class>
  listener>

  
  <context-param>
    <param-name>contextConfigLocationparam-name>
    <param-value>classpath:applicationContext.xmlparam-value>
  context-param>

  
  <servlet>
    <servlet-name>dispatcherServletservlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServletservlet-class>
    
    <init-param>
      <param-name>contextConfigLocationparam-name>
      <param-value>classpath:applicationContext-mvc.xmlparam-value>
    init-param>
    
    <load-on-startup>1load-on-startup>
  servlet>
  <servlet-mapping>
    <servlet-name>dispatcherServletservlet-name>
    
    <url-pattern>/url-pattern>
  servlet-mapping>

  
  <filter>
    <filter-name>characterEncodingFilterfilter-name>
    <filter-class>org.springframework.web.filter.CharacterEncodingFilterfilter-class>
    <init-param>
      <param-name>encodingparam-name>
      <param-value>UTF-8param-value>
    init-param>
    <init-param>
      <param-name>forceEncodingparam-name>
      <param-value>trueparam-value>
    init-param>
  filter>
  <filter-mapping>
    <filter-name>characterEncodingFilterfilter-name>
    <url-pattern>/*url-pattern>
  filter-mapping>
web-app>

3.Controller层

import com.lty.aisell.common.JsonResult;
import com.lty.aisell.common.UIPage;
import com.lty.aisell.domain.Employee;
import com.lty.aisell.query.EmployeeQuery;
import com.lty.aisell.service.IEmployeeService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

import java.util.List;

@Controller
@RequestMapping("/employee")
public class EmployeeController {
     
    @Autowired
    IEmployeeService employeeService;

    @RequestMapping("/index")
    public String index(){
     
        return "employee/index";
    }

    @RequestMapping("/list")
    @ResponseBody
    public List<Employee> list(){
     
        List<Employee> list = employeeService.findAll();
        return list;
    }

    /*分页查询*/
    @RequestMapping("/page")
    @ResponseBody
    public UIPage<Employee> page(EmployeeQuery query){
     
        Page<Employee> page = employeeService.queryPage(query);
        return new UIPage<Employee>(page);
    }
    
}

三、集成EasyUI

（一）把相应的文件拷备到项目中

（二）抽取引入easyui的代码

• 把所有公共的引入(css,js) 都放在head.jsp中
• 以后要使用easyui直接引入即可

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%-- 引入easyui的样式 --%>

<%-- 引入easyui的图标样式 --%>

<%-- 引入jQuery --%>

<%--jQuery的扩展包 --%>

<%--引入easyui的核心文件--%>

<%-- 引入一个国际化（中文）文件 --%>

（三）员工的查询页面

1.employee.jsp

• 使用EasyUI中的Grid控件来完成

<%@ page contentType="text/html;charset=UTF-8" language="java" %>


    
    <%--引入头部文件--%>
    <%@include file="/WEB-INF/views/head.jsp"%>
    <%--引入当前模块对应的js--%>
    



<%--工具栏--%>

    

        添加
        修改
        删除
    
    

        用户名: 
        邮件: 
        查询
    


<%--
    fitColumns : 自适应列
    fit : 自适应父容器
    singleSelect ：单选
    pagination : 分页栏
    url : 获取数据的路径
--%>

    

    

        
编码
        
名字
        
密码
        
邮件
        
年龄
    
    

2.Page对象封装

• 前台要集成Easyui，SpringDataJpa返回的数据和EasyUI中的数据匹配不上
• Easyui在分页时想要的数据结构{total:xx,rows:[...]}
• 准备UIPage来匹配这个结构

import org.springframework.data.domain.Page;

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

/**
 * easyui显示分页数据
 * @param 
 */
public class UIPage<T> {
     
    private Long total;//总条数
    private List<T> rows = new ArrayList<>();//每页数据

    //在构造的时候把page对象变成前端需要的结果
    public UIPage(Page page) {
     
        this.total = page.getTotalElements();
        this.rows = page.getContent();
    }
	//省略getter，setter方法
}

3.修改抽取的查询对象

• EasyUI查询传参的名称如果和BaseQuery中接收的名称不一致，需要修改BaseQuery这个类进行功能的兼容

import org.apache.commons.lang3.StringUtils;
import org.springframework.data.domain.Sort;
import org.springframework.data.jpa.domain.Specification;

public abstract class BaseQuery {
     
    //当前页
    private int currentPage = 1;
    //每页条数
    private int pageSize = 10;
    //排序字段
    private String orderName;
    //排序类型 (true = DESC/ false = ASC)
    private boolean orderType = false;
    //每个子类必须有查询规则的方法
    public abstract Specification createSpec();


    public int getCurrentPage() {
     
        return currentPage;
    }

    //兼容JPA从0页作为起始页
    public int getJPACurrentPage() {
     
        return currentPage-1;
    }

    public void setCurrentPage(int currentPage) {
     
        this.currentPage = currentPage;
    }

    //兼容easyui当前页数
    public void setPage(int page){
     
        this.currentPage = page;
    }

    public int getPageSize() {
     
        return pageSize;
    }

    public void setPageSize(int pageSize) {
     
        this.pageSize = pageSize;
    }

    //兼容easyui每页条数
    public void setRows(int rows){
     
        this.pageSize = rows;
    }
	//省略getter，setter方法
}

4.当前模块对应的js

• 引入jquery.serializejson.js这个控件，可以直接拿到一个表单中的所有值，并且封装成一个json数据

$(function () {
     
    /*常用元素获取*/
    var datagrid = $("#datagrid");
    var searchForm = $("#searchForm")

    /*注册事件*/
    $("a[data-method]").on("click",function () {
     
        ///拿到当前对应的方法名
        var methodName = $(this).data("method");
        //执行对应的方法(动态调用)
        lty[methodName]();
    })

    /*相应的方法功能*/
    lty = {
     
        add(){
     

        },
        update(){
     

        },
        delete() {
     
         
        },
        //高级查询
        search: function () {
     
            //拿到查询的值（需要先引入jquery.jdirk.js 才可以使用这个方法）
            var params = searchForm.serializeObject();
            //进行查询
            datagrid.datagrid("load",params);
        }
    }
})