后端-SSH，开发项目中可能用到的一些方法

目录

不同账号登录不同页面

中文乱码方法

搜索模糊查询

权限登录功能置灰

Tab子父页面显示

子父页面数据显示

登录查询功能

根据年份数据显示

修改密码

赋予多者权限

数据库连接

前端数据crud存入后端

封装的多个参数进行CRUD

前端“页数”

提交表单

---

不同账号登录不同页面

if (rs.next()) {
            String role = rs.getString("usertype");
            if("管理员".equals(role)){
                url = "/pages/user/user_homepage.jsp?user_id="+user_id;
            }else if("辅导员".equals(role)){
                url = "/pages/instructor/inst_homepage.jsp?user_id="+user_id;
            }else if("学生".equals(role)){
                url = "/pages/leave/leave_homepage.jsp?user_id="+user_id;
            }else{
                url = "/pages/user/error.jsp?user_id="+user_id;
            }

中文乱码方法

public String toUtf8(String content) throws UnsupportedEncodingException {
        if (Objects.isNull(content)) {
            return "";
        }
        return new String(content.getBytes("ISO-8859-1"), "UTF-8");
    }

搜索模糊查询

Dao的实现类里

if (!Objects.isNull(equipName) && !equipName.isEmpty()) {// 按照名称模糊查询数据
                            hql += " and equipName like :equipName";
                            query = session.createQuery(hql);
                            try {
                                query.setString("equipName", "%" + new String(equipName.getBytes("ISO-8859-1"),"UTF-8") + "%");
                            } catch (UnsupportedEncodingException e) {
                                e.printStackTrace();
                            }
                        }else {
                            query = session.createQuery(hql);
                        }
                        List<EquipmentEntity> list = query.list();
                        return list;
                    }

权限登录功能置灰

描述：在.jsp前端页面完成，不同的登录用户，登陆页面后显示的页面所包含的功能按钮不同

思路： → 在代码部分写.onload方法

<script type="text/javascript">
        window.onload = function(){
            var userType = '<s:property value="#session.user.userType"/>';
            if (userType == '2'){// 项目负责人
                $("#develop").hide();
                $("#leader").hide();
                $("#system").hide();
            }else if (userType == '3'){// 发改局
                $("#leader").hide();
                $("#manager").hide();
                $("#system").hide();
            }else if (userType == '4'){// 领导
                $("#develop").hide();
                $("#manager").hide();
                $("#system").hide();
            }
        };
    </script>

→不同的用户通过session引入usertype

var userType = '<s:property value="#session.user.userType"/>';

→在功能按钮给个id

            <li id="develop" class="layui-nav-item"><a href="javascript:;" data-id="8" data-title="发改局" onclick="removeHome()" data-url="account.jsp"
                                          class="site-demo-active" data-type="tabAdd" class="AccountAction" lay-event="develop">发改局</a></li>
            <li id="leader" class="layui-nav-item"><a href="javascript:;" data-id="9" data-title="领导书记" onclick="removeHome()" data-url="account.jsp"
                                          class="site-demo-active" data-type="tabAdd"class="AccountAction" lay-event="leader">领导书记</a></li>
            <li id="manager" class="layui-nav-item"><a href="javascript:;" data-id="10" data-title="项目负责人" onclick="removeHome()" data-url="account.jsp"
                                          class="site-demo-active" data-type="tabAdd"class="AccountAction" lay-event="manager">项目负责人</a></li>
            <li id="system" class="layui-nav-item"><a href="javascript:;" data-id="11" data-title="项目管理者" onclick="removeHome()" data-url="account.jsp"
                                          class="site-demo-active" data-type="tabAdd"class="AccountAction" lay-event="system">项目管理者</a></li>

Tab子父页面显示

描述：在.jsp前端页面完成，首页有父页面的显示，点击tab选项卡，会显示子选项内容，父页面内容隐藏

思路：→写个移除父页面的方法

<script>
function removeHome() {
            // 移除tbody
            $("#yearHome").remove();
        }
</script>

→按钮把上方法给onclick点击

data-type=“tabAdd”大的父页面下再出现子框架

data-url进行点击后的子页面跳转地址

<li id="system" class="layui-nav-item"><a href="javascript:;" data-id="11" data-title="项目管理者" onclick="removeHome()" data-url="account.jsp"
                                          class="site-demo-active" data-type="tabAdd"class="AccountAction" lay-event="system">项目管理者</a></li>

子父页面数据显示

描述：大的框架不动，点击不同的tab页面会有相应不同的数据显示

思路：→dao的方法里SystemDao

List<ProjectEntity> projectNames(String proName);

→dao的方法实现类SystenDaoImpl(*实现类要继承SystemDao)

@Repository
public class SystemDaoImpl extends HibernateDaoSupport implements SystemDao {
@Override
//  查询project表
  public List<ProjectEntity> projectNames(String proName) {
    return getHibernateTemplate().execute(new HibernateCallback<List<ProjectEntity>>() {
      @Override
      public List<ProjectEntity> doInHibernate(Session session) throws HibernateException {
        String hql = "from ProjectEntity where proName = ?";
        Query query = session.createQuery(hql);
        query.setParameter(0, proName);
        List<ProjectEntity> list = query.list();
        return list;
      }
    });
  }
}

→在SystemAction里面：把从数据库查询到的数据放在“projects”里面，是根据项目名称查询的（一键get set）

  private String projectName;
  private Map<String,Object> request;
  private List<SystemStatisticEntity> datas;
  private List<ProjectEntity> data;

public String names() throws UnsupportedEncodingException {
    // 中文乱码问题
    String name = new String(projectName.getBytes("ISO-8859-1"), "UTF-8");
    // 根据projectName查询数据库
    List<ProjectEntity> datas = systemService.projectNames(name);
    // 放到request
    request.put("projects", datas);
    return "projects";
  }

→在systemService里

List<ProjectEntity> projectNames(String proName);

→SystemServiceImpl实现类（说明返回对象）继承SystemService接口。

@Service
public class SystemServiceImpl implements SystemService {

  @Resource
  private SystemDao systemDao;
  @Override
  public List<ProjectEntity> projectNames(String proName) {
    return systemDao.projectNames(proName);
  }
}

→写tab的子页面显示data-url="project_names.action?projectName=居民广场“，执行action的动作，根据查询的名称去提出来一连串数据

<dl class="layui-nav-child">
                        <dd><a href="javascript:;" data-id="3" data-title="居民广场" onclick="removeHome()" data-url="project_names.action?projectName=居民广场"
                               class="site-demo-active" data-type="tabAdd">居民广场</a></dd>
                    </dl>

→在进行配置

<!--項目統計-->
		<action name="project_*" class="com.xmgc.models.action.SystemAction" method="{1}">
			<result name="success" type="json">
				<param name="root">datas</param>
			</result>
			<result name="projects">/system.jsp</result>
		</action>

登录查询功能

描述：登陆时根据账号把密码也查询出来，输入密码后，账号密码一致，登陆成功

思路：

→前端.jsp页面要执行action动作,name="username",name="password"对应数据

<form action="user_login.action" method="post">
       用户名： <input type="text" name="username" onFocus="this.value = '';" onBlur="if (this.value == '') {this.value = '用户名';}"
               required="">
        密码：<input type="password" name="password" onFocus="this.value = '';" onBlur="if (this.value == '') {this.value = '密码';}"
               required="">
        <input type="submit" value="登录">
    </form>

→在AccountDao里

public interface AccountDao {
  AccountEntity validateAccount(String userName, String userPwd);
  AccountEntity findByUserName(String userName);
}

→在AccountService里

public interface AccountService {
  AccountEntity validateAccount(String userName, String userPwd);
  AccountEntity findByUserName(String userName);
}

→在AccountDaoImpl中写俩方法(继承AccountDao接口)

查询账号密码 、核对登陆的密码与数据库里密码的一致性

@Repository
public class AccountDaoImpl extends HibernateDaoSupport implements AccountDao {

  @Autowired
  public void setMySessionFactory(SessionFactory sessionFactory) {
    super.setSessionFactory(sessionFactory);
  }
//查询两个一致性
  @Override
  public AccountEntity validateAccount(String userName, String userPwd) {
    AccountEntity entity = findByUserName(userName);
    if(entity == null || !entity.getUserPwd().equals(userPwd)){
      return null;
    }
    return entity;
  }
//查询数据库里的账号密码
  @Override
  public AccountEntity findByUserName(String userName) {
    return getHibernateTemplate().execute(new HibernateCallback<AccountEntity>() {
      @Override
      public AccountEntity doInHibernate(Session session) throws HibernateException {
        String hql = "from AccountEntity where userName = ?";
        Query query = session.createQuery(hql);
        query.setParameter(0, userName);
        AccountEntity user = (AccountEntity) query.uniqueResult();
        return user;
      }
    });
  }

→在AccountAction中

//log方法对应struts.xml中的action配置
  public String login() {
    boolean validated = false;//验证成功标识
    AccountEntity user = userService.validateAccount(getUsername(), getPassword());

    if (user != null) {
      validated = true;
    }
    if (validated) {
      //验证成功返回字符串“success”
      session.put("user", user);
      //若登陆成功则将该user记录在session中

→在相应的struts.xml文件中进行配置,返回的是json类型，就只有数据不会再跳转页面

action都要进行配置，设定返回的类型是数据还是页面

<!-- 登陆 -->
		<action name="user_*" class="com.xmgc.models.action.AccountAction" method="{1}">
			<result name="success">/begin.jsp</result>
			<result name="error">/error.jsp</result>
			<result name="account">/account.jsp</result>
			<result name="updateSuccess" type="json">
			<param name="root">msg</param>
			</result>
		</action>

根据年份数据显示

描述：从数据库调数据到前台显示，根据年份显示

思路

→在SystemAction里面(继承接口RequestAware) get set一键创建

查询的数据放到datas里

public class SystemAction extends ActionSupport implements RequestAware {
  //年份获取信息
  private String year;
  private Map<String,Object> request;
  private Map<String,Object> session;
  //注入bean
  @Resource
  private SystemService systemService;

  public String types() throws Exception{
    if(StringUtils.isBlank(year)){
      datas = new ArrayList<>();
    }else {
      datas = systemService.projectTypeNums(Integer.parseInt(year));
      if(datas == null){
        datas = new ArrayList<>();
      }
    }
    return SUCCESS;
  }

→创建接口SystemService

public interface SystemService {
  /**
   * 项目类型统计
   * @param year 年度
   * @return
   */
  List<SystemStatisticEntity> projectTypeNums(int year);
}

→在SystemDao里

public interface SystemDao {
  /**
   * 项目类型统计
   * @param year 年度
   * @return
   */
  List<SystemStatisticEntity> projectTypeNums(int year);

→在SystemDaoImpl实现类里查询表，根据年份的查询返回数据

@Repository
public class SystemDaoImpl extends HibernateDaoSupport implements SystemDao {

  @Autowired
  public void setMySessionFactory(SessionFactory sessionFactory) {
    super.setSessionFactory(sessionFactory);
  }

  @Override
//  查询system表
  public List<SystemStatisticEntity> projectTypeNums(int year) {
    return getHibernateTemplate().execute(new HibernateCallback<List<SystemStatisticEntity>>() {
      @Override
      public List<SystemStatisticEntity> doInHibernate(Session session) throws HibernateException {
        String hql = "from SystemStatisticEntity where year = ?";
        Query query = session.createQuery(hql);
        query.setParameter(0, year);
        List<SystemStatisticEntity> list = query.list();
        return list;
      }
    });
  }
}

→查询的数据放到projects

//log方法对应struts.xml中的action配置
 public class AccountAction extends ActionSupport implements RequestAware,SessionAware {
 public String login() {
      // 项目类型统计（默认查询当前年份）
      List<SystemStatisticEntity> datas = systemService.projectTypeNums(LocalDateTime.now().getYear());
      if (datas != null && !datas.isEmpty()) {
        request.put("projects", datas);
      }else{
        request.put("projects", new ArrayList<>());
      }
      return SUCCESS;
    } else {
      //验证失败返回字符串“error”
      return ERROR;
    }
  }
}

→在.jsp页面 设定好哪一行的数据对应显示在谁下面 用projects取值

<%@ taglib prefix="s" uri="/struts-tags" %>
//用标签<s:iterator></s:iterator>头部要引用

<thead>
                <th>项目类型</th>
                <th>总数量</th>
                <th>项目总投资</th>
                <th>年度计划投资</th>
                <th>实际完成投资</th>
                <th>年度开工/天</th>
                <th>实际开工/天</th>
                <th>计划竣工/天</th>
                <th>实际竣工/天</th>
                </tr>
                </thead>
                <tbody id="datas">
                <s:iterator value="#request.projects" status="project">
                    <tr>
                        <td><s:property value="proType"/></td>
                        <td><s:property value="totalNum"/></td>
                        <td><s:property value="totalMoney"/></td>
                        <td><s:property value="finishedMoney"/></td>
                        <td><s:property value="planMoney"/></td>
                        <td><s:property value="finishedWorkDay"/></td>
                        <td><s:property value="planWorkDay"/></td>
                        <td><s:property value="finishedCompletedDay"/></td>
                        <td><s:property value="planCompletedDay"/></td>
                    </tr>
                </s:iterator>

→在相应的struts.xml文件中进行配置,返回的是json类型，就只有数据不会再跳转页面

action都要进行配置，设定返回的类型是数据还是页面

<!--項目統計-->
<action name="project_*" class="com.xmgc.models.action.SystemAction" method="{1}">
			<result name="success" type="json">
				<param name="root">datas</param>
			</result>
			<result name="projects">/system.jsp</result>
</action>

修改密码

描述：根据登陆的账户，查询账户，前端输入密码，直接把新密码放在账户下，生成新的密码

思路：

→AccountAction里写，数据放在username里

setUserPwd修改后的数据放进数据库

public class AccountAction extends ActionSupport implements RequestAware,SessionAware {
  private String msg = "修改失败！";
  private Map<String,Object> request;
  private Map<String,Object> session;
  //注入bean
  @Resource
  private AccountService userService;
  @Resource
  private SystemService systemService;

  public String toUpdatePwdPage(){
    request.put("username", username);
    return "account";
  }

  public String updatePwd(){
    AccountEntity entity = userService.findByUserName(username);
    if(entity == null){
      msg = "用户不存在，修改失败！";
    }else{
      entity.setUserPwd(password);
      userService.updatePwd(entity);
      msg = "修改成功！";
    }
    return "updateSuccess";
  }

→AccountService里进行方法创建

public interface AccountService {
  void updatePwd(AccountEntity entity);
}

→在修改密码页面的前端 ,从username中取值

<div class="layui-input-block">
            <s:hidden id="username" value="%{#request.username}" name="username"></s:hidden>
            <input id="password" type="text" name="password" lay-verify="title" <%--autocomplete="off"--%> placeholder="再次输入新密码，立即提交后刷新页面重新登陆" class="layui-input">
        </div>

→在修改密码页面的前端.jsp页面

• 最后提交按钮给onclick方法

<div class="layui-input-block">
            <button type="submit" class="layui-btn" lay-submit="" lay-filter="demo1" onclick="check()">立即提交</button>
        </div>

• • • • onclick方法写在前端

<script>

    function check() {
        var data = $("#form").serializeArray();
        $.ajax({
            type: "POST",
            url: "user_updatePwd.action",
            data: data,
            dataType: "text",
            async: false,
            success: function (message) {
                $("#message").html(eval(message));
            }
        });
        return false;
    }
    });
</script>

→在AccountDaoImpl里 得到输入的值

@Repository
public class AccountDaoImpl extends HibernateDaoSupport implements AccountDao {
@Override
  public void updatePwd(AccountEntity entity) {
    if(entity == null || entity.getId() <= 0){
      return;
    }
    getHibernateTemplate().update(entity);
  }
}

→在相应的struts.xml文件中进行配置,返回的是json类型，就只有数据不会再跳转页面

action都要进行配置，设定返回的类型是数据还是页面

<!-- 登陆 -->
		<action name="user_*" class="com.xmgc.models.action.AccountAction" method="{1}">
			<result name="success">/begin.jsp</result>
			<result name="error">/error.jsp</result>
			<result name="account">/account.jsp</result>
			<result name="updateSuccess" type="json">
			<param name="root">msg</param>
			</result>
		</action>

赋予多者权限

<s:if test="#session.user.userType == 2 || #session.user.userType == 1">
</s:if>

数据库连接

在resources里.properties，直接输入数据库名字密码（框架连接）

hibernate.dialect=org.hibernate.dialect.MySQL5Dialect
jdbc.driverClassName=com.mysql.cj.jdbc.Driver
jdbc.validationQuery=SELECT 1 FROM DUAL
jdbc.url=jdbc:mysql://47.100.92.76:3306/xmgc?characterEncoding=utf8&useSSL=false&serverTimezone=Asia/Shanghai&rewriteBatchedStatements=true

jdbc.username=root
jdbc.password=123456

hibernate.hbm2ddl.auto=update
hibernate.show_sql=true
hibernate.format_sql=true
hibernate.autoReconnect=true

前端数据crud存入后端

→创建ManagerService接口，等着实现类去写具体方法。

public interface ManagerService {
  //定义插入方法
  String add(ProjectEntity projectEntity);

  //定义遍历查询方法
  List findall();

  ProjectEntity findid(int id);

  //定义删除
  int del(int id);

  //定义修改
  void edit(ProjectEntity projectEntity);
}

→在ManagerDao接口里定义方法，等着去实现类里进行具体实现

public interface ManagerDao {
    //定义插入方法
    String add(ProjectEntity projectEntity);
    //定义查询方法
    List findall();
    ProjectEntity findid(int id);
    //定义删除方法
    int del(int id);
    //定义修改方法
    void edit(ProjectEntity projectEntity);

→ManagerDaoImpl实现类继承接口，对HibernateDaoSupport重写，写具体的方法

@Repository
public class ManagerDaoImpl extends HibernateDaoSupport implements ManagerDao {

    @Autowired
    public void setSessionFactoryOverride(SessionFactory sessionFactory) {
        super.setSessionFactory(sessionFactory);
    }

    @Override
    //插入操作
    public String add(ProjectEntity projectEntity) {
        return getHibernateTemplate().save(projectEntity).toString();
    }

    //查找操作
    public List<ProjectEntity> findall() {
        String sql = "from ProjectEntity";
        ArrayList<ProjectEntity> list = (ArrayList<ProjectEntity>) this.getHibernateTemplate().find(sql);
        return list;
    }

    //根据项目的id进行查询
    public ProjectEntity findid(int id) {
        ProjectEntity dd = this.getHibernateTemplate().get(ProjectEntity.class, id);
        return dd;
    }

    //删除操作
    public int del(int id) {
        //实例化对象
        ProjectEntity dd = new ProjectEntity();
        dd.setId(id);
        this.getHibernateTemplate().delete(dd);
        int tt = 1;
        return tt;
    }

    //修改操作
    public void edit(ProjectEntity projectEntity) {
        this.getHibernateTemplate().update(projectEntity);
    }
}

→ManagerServiceImpl实现类写具体方法

@Service
public class ManagerServiceImpl implements ManagerService {

    @Resource
    private ManagerDao managerDao;

    //注入事务管理
    @Transactional(rollbackFor = {Exception.class,RuntimeException.class})

     //插入操作
    public String add(ProjectEntity projectEntity) {

        return managerDao.add(projectEntity);
    }

    //查询操作
    public List<ProjectEntity> findall(){
        return  managerDao.findall();

    }
    public ProjectEntity findid(int id){
        return managerDao.findid(id);
    }

    //删除操作
    public int del(int id){

        return managerDao.del(id);
    }

    //修改操作
    public void edit(ProjectEntity projectEntity){

        managerDao.edit(projectEntity);
    }

}

ManageAction里

public class ManagerAction extends ActionSupport implements SessionAware {
  @Resource
  private ManagerService managerService;
  private int id;
  private Long proMoney;
  private String proName;
  private String proType;
  private String proManager;
  private int managerNum;
  private String chargeDepart;
  private String leaderName;
  private String leaderNum;
  private String proYear;
  private String proBegin;
  private String proFinish;
  private String proAddress;

  private Map<String, Object> session;

  public String add() {

    //进行格式转化
    try {

      ProjectEntity projectEntity = new ProjectEntity();
      projectEntity.setProMoney(getProMoney());
      projectEntity.setProName(getProName());
      projectEntity.setProType(getProType());
      projectEntity.setProManager(getProManager());
      projectEntity.setManagerNum(getManagerNum());
      projectEntity.setChargeDepart(getChargeDepart());
      projectEntity.setLeaderName(getLeaderName());
      projectEntity.setLeaderNum(getLeaderNum());
      projectEntity.setProYear(csrq1);
      projectEntity.setProBegin(csrq2);
      projectEntity.setProFinish(csrq3);
      projectEntity.setProAddress(getProAddress());

      managerService.add(projectEntity);

    } catch (Exception e) {

      e.printStackTrace();
    }
    return SUCCESS;
  }
}

封装的多个参数进行CRUD

→ProcessDaoImpl里为具体方法的实现

@Repository
@Transactional
public class ProcessDaoImpl extends HibernateDaoSupport implements ProcessDao {
    //创建DetachedCriteria对象
    private DetachedCriteria criteria;
    // 把SessionFactory注入到父类中
    @Autowired
    public void setMySessionFactory(SessionFactory sessionFactory){
        //调用父类的SessionFactory 传递到父类 保证SessionFactory唯一
        super.setSessionFactory(sessionFactory);
    }

    public String save(ProcessEntity processEntity) {
        //保存processEntity
        this.getHibernateTemplate().save(processEntity);
        if(this.getHibernateTemplate()!=null){
            return "save";
        }
        return null;
    }

    @Override
    public int findProcessCount(boolean isAdmin, String managerNum) {
        //查询对应负责人的所有记录数
        return this.findCount(isAdmin, managerNum);

    }

//分页查询项目进度汇报
    @Override
    public List<ProcessEntity> findProcess(boolean isAdmin, ProcessEntity processEntity, int begin, int pageSize) {
        criteria = DetachedCriteria.forClass(ProcessEntity.class);
        if(!isAdmin) {// 非超管
            //按负责人工号查询
            if (processEntity.getManagerNum() != null && !processEntity.getManagerNum().isEmpty()) {
                criteria.add(Restrictions.like("managerNum", processEntity.getManagerNum()));
            }
        }
        List<ProcessEntity> processEntityList = (List<ProcessEntity>) this.getHibernateTemplate().findByCriteria(criteria,begin,pageSize);
        return processEntityList;
    }
    //查询负责人对应的项目的记录数
    @Override
    public int findProjectCount(boolean isAdmin, Integer managerNum) {
        String hql = "SELECT COUNT(*) from com.xmgc.models.pojo.ProjectEntity ";
        Query query = null;
        if (isAdmin) {
            query = currentSession().createQuery(hql);
        }else{
            if(managerNum == null){
                return 0;
            }
            hql += " where ManagerNum=? ";
            query = currentSession().createQuery(hql);
            query.setInteger(0, managerNum);
        }

        List<Long> list =  query.list();
        if(list.size()>0){
            return list.get(0).intValue();
        }
        return 0;
    }

→ProcessDao接口里写个方法

//ProcessDao接口
public interface ProcessDao {
    //保存processEntity
    String save(ProcessEntity processEntity);

    int findProcessCount(boolean isAdmin, String managerNum);

    List<ProcessEntity> findProcess(boolean isAdmin, ProcessEntity processEntity, int begin, int pageSize);

    int findProjectCount(boolean isAdmin, Integer managerNum);
}

→ProcessService

public interface ProcessService {

    String save(ProcessEntity processEntity);//保存

    PageBeanEntity<ProcessEntity> findProcess(boolean isAdmin, ProcessEntity processEntity, int currPage);

    PageBeanEntity<ProjectEntity> findProject(boolean isAdmin,ProjectEntity projectEntity, int currPage);
}

→ProcessServiceImpl 写具体的保存、查项目进度、查项目名称

@Service
public class ProcessServiceImpl implements ProcessService {

    private ProcessDao processDao;
    @Autowired
    public void setProcessDao(ProcessDao processDao) {
        this.processDao = processDao;
    }

    public String save(ProcessEntity processEntity) {
       return processDao.save(processEntity);
    }
@Override
    public PageBeanEntity<ProcessEntity> findProcess(boolean isAdmin, ProcessEntity processEntity, int currPage) {
        PageBeanEntity<ProcessEntity> pageBean = new PageBeanEntity<ProcessEntity>();
        //封装当前页数
        pageBean.setCurrPage(currPage);
        //封装每页显示记录数
        int pageSize = 10;
        pageBean.setPageSize(pageSize);
        //封装总记录数
        int totalCount = processDao.findProcessCount(isAdmin, processEntity.getManagerNum());
        pageBean.setTotalCount(totalCount);
        //封装总页数
        double tc = totalCount;
        Double sum = Math.ceil(tc/pageSize);
        pageBean.setTotalPage(sum.intValue());
        if(totalCount == 0){// 总数为0,则不用再去查询分页数据了
            return pageBean;
        }
        //封装每页显示的数据
        int begin = (currPage-1)*pageSize;
        List<ProcessEntity> list = processDao.findProcess(isAdmin, processEntity, begin, pageSize);
        pageBean.setList(list);
        return pageBean;
    }
    //查询
    @Override
    public PageBeanEntity<ProjectEntity> findProject(boolean isAdmin,ProjectEntity projectEntity, int currPage) {
        PageBeanEntity<ProjectEntity> pageBean = new PageBeanEntity<ProjectEntity>();
        //封装当前页数
        pageBean.setCurrPage(currPage);
        //封装每页显示记录数
        int pageSize = 12;
        pageBean.setPageSize(pageSize);
        //封装总记录数
        int totalCount = processDao.findProjectCount(isAdmin, projectEntity.getManagerNum());
        pageBean.setTotalCount(totalCount);
        //封装总页数
        double tc = totalCount;
        Double sum = Math.ceil(tc/pageSize);
        pageBean.setTotalPage(sum.intValue());
        if(totalCount == 0){// 总数为0,则不用再去查询分页数据了
            return pageBean;
        }
        //封装每页显示的数据
        int begin = (currPage-1)*pageSize;
        List<ProjectEntity> list = processDao.findProject(isAdmin, projectEntity, begin, pageSize);
        pageBean.setList(list);
        return pageBean;
    }
}

→ProcessAction保存项目汇报的Action方法

public String save() {
        //调用业务层的save方法
        HttpServletRequest request = ServletActionContext.getRequest();
        //把JSON字符串转换成实体类对象
        ProcessEntity processEntity = JSON.parseObject(request.getParameter("save"),ProcessEntity.class);
        String bool =  processService.save(processEntity);
        processService.save(processEntity);
        if(bool!=null){
            msg = "项目进度上传成功";
        } else
        msg = "项目进度上传失败！！请重试";
        return SUCCESS;
    }

前端“页数”

描述：查询出的项目进度数据，有很多条数据，要分页显示

→PageBeanEntity创建实体类

public class PageBeanEntity<T> {
    private int currPage;//当前页数
    private int pageSize;//每页显示的记录数
    private int totalCount;//总记录数
    private int totalPage;//总页数
    private List<T> list;//每页显示的数据
}

→ProcessService接口里

public interface ProcessService {
PageBeanEntity<ProcessEntity> findProcess(boolean isAdmin, ProcessEntity processEntity, int currPage);
}

→ ProcessServiceImpl实现类继承接口写具体操作

@Override
public class ProcessServiceImpl implements ProcessService {
    public PageBeanEntity<ProcessEntity> findProcess(boolean isAdmin, ProcessEntity processEntity, int currPage) {
        PageBeanEntity<ProcessEntity> pageBean = new PageBeanEntity<ProcessEntity>();
        //封装当前页数
        pageBean.setCurrPage(currPage);
        //封装每页显示记录数
        int pageSize = 10;
        pageBean.setPageSize(pageSize);
        //封装总记录数
        int totalCount = processDao.findProcessCount(isAdmin, processEntity.getManagerNum());
        pageBean.setTotalCount(totalCount);
        //封装总页数
        double tc = totalCount;
        Double sum = Math.ceil(tc/pageSize);
        pageBean.setTotalPage(sum.intValue());
        if(totalCount == 0){// 总数为0,则不用再去查询分页数据了
            return pageBean;
        }
        //封装每页显示的数据
        int begin = (currPage-1)*pageSize;
        List<ProcessEntity> list = processDao.findProcess(isAdmin, processEntity, begin, pageSize);
        pageBean.setList(list);
        return pageBean;
    }
}
→

提交表单

→在struts配置文件进行action的配置

<action name="processAction_*" class="com.xmgc.models.action.ProcessAction" method="{1}">

→前端jsp页面调用saveform(名字随便起，要和js代码相对应就行)提交表格

<body>
<form class="layui-form layui-form-pane" action="" method="POST" id="saveForm" style="width: 70% ">
 页面中的内容，各种div标签

    </form>
</body>

→前端Jsp页面js代码部分进行action的调用(此处用到layui框架不用多管)

$.each($("#saveForm").serializeArray(), function (i, field) {
                        $.post("<%=basePath%>biz/processAction_save.action",