六、Spring练习

文章目录

Spring练习环境搭建
- Spring环境搭建步骤
- 用户和角色的关系
角色列表的展示和添加操作
- 角色列表的展示效果
- 角色列表的展示步骤分析
角色添加的效果
角色添加的步骤分析
用户列表的展示和添加操作
- 用户列表的展示效果
- 用户列表的展示步骤分析
- 用户添加的效果
- 用户添加的步骤分析
- 删除用户的效果
- 删除用户的步骤分析
项目情况
- 依赖
- sql 语句创建表
- 项目结构
- resources 下的配置文件
- web.xml
- java文件
- - controller
  - dao
  - - impl
  - domain
  - interceptor
  - service
  - - impl

Spring练习环境搭建 Spring环境搭建步骤

① 创建工程（Project&Module）
② 导入静态页面（jsp页面）
③ 导入需要坐标（pom.xml）
④ 创建包结构（controller、service、dao、domain、utils）
⑤ 导入数据库脚本（见资料test.sql）
⑥ 创建POJO类（见资料User.java和Role.java）
⑦ 创建配置文件（applicationContext.xml、spring-mvc.xml、jdbc.properties、log4j.properties）

用户和角色的关系

角色列表的展示和添加操作角色列表的展示效果

角色列表的展示步骤分析

① 点击角色管理菜单发送请求到服务器端（修改角色管理菜单的url地址）
② 创建RoleController和showList()方法
③ 创建RoleService和showList()方法
④ 创建RoleDao和findAll()方法
⑤ 使用JdbcTemplate完成查询操作
⑥ 将查询数据存储到Model中
⑦ 转发到role-list.jsp页面进行展示

角色添加的效果

角色添加的步骤分析

① 点击列表页面新建按钮跳转到角色添加页面
② 输入角色信息，点击保存按钮，表单数据提交服务器
③ 编写RoleController的save()方法
④ 编写RoleService的save()方法
⑤ 编写RoleDao的save()方法
⑥ 使用JdbcTemplate保存Role数据到sys_role
⑦ 跳转回角色列表页面

用户列表的展示和添加操作用户列表的展示效果

用户列表的展示步骤分析

① 点击用户管理菜单发送请求到服务器端（修改用户管理菜单的url地址）
② 创建RoleController和showList()方法
③ 创建RoleService和showList()方法
④ 创建RoleDao和findAll()方法
⑤ 使用JdbcTemplate完成查询操作
⑥ 将查询数据存储到Model中
⑦ 转发到user-list.jsp页面进行展示

用户添加的效果

用户添加的步骤分析

删除用户的效果

删除用户的步骤分析

① 点击用户列表的删除按钮，发送请求到服务器端
② 编写UserController的deleteById()方法
③ 编写UserService的deleteById()方法
④ 编写UserDao的deleteById()方法
⑤ 编写UserDao的deleteRelByUid()方法
⑥ 跳回当前用户列表页面

项目情况依赖

pom.xml




  4.0.0
  war

  spring_test
  com.lzjtu
  spring_test
  1.0-SNAPSHOT

  
    
      mysql
      mysql-connector-java
      5.1.32
    
    
      c3p0
      c3p0
      0.9.1.2
    
    
      com.alibaba
      druid
      1.1.10
    
    
      junit
      junit
      4.12
      test
    
    
      org.springframework
      spring-context
      5.0.5.RELEASE
    
    
      org.springframework
      spring-test
      5.0.5.RELEASE
    
    
      org.springframework
      spring-web
      5.0.5.RELEASE
    
    
      org.springframework
      spring-webmvc
      5.0.5.RELEASE
    
    
      javax.servlet
      javax.servlet-api
      3.0.1
      provided
    
    
      javax.servlet.jsp
      javax.servlet.jsp-api
      2.2.1
      provided
    
    
      com.fasterxml.jackson.core
      jackson-core
      2.9.0
    
    
      com.fasterxml.jackson.core
      jackson-databind
      2.9.0
    
    
      com.fasterxml.jackson.core
      jackson-annotations
      2.9.0
    
    
      commons-fileupload
      commons-fileupload
      1.3.1
    
    
      commons-io
      commons-io
      2.3
    
    
      commons-logging
      commons-logging
      1.2
    
    
      org.slf4j
      slf4j-log4j12
      1.7.7
    
    
      log4j
      log4j
      1.2.17
    
    
      org.springframework
      spring-jdbc
      5.0.5.RELEASE
    
    
      org.springframework
      spring-tx
      5.0.5.RELEASE
    
    
      jstl
      jstl
      1.2

sql 语句创建表



;

;

;
;
;
;
CREATE DATABASE `test` ;

USE `test`;



DROP TABLE IF EXISTS `sys_role`;

CREATE TABLE `sys_role` (
  `id` bigint(20) NOT NULL AUTO_INCREMENT,
  `roleName` varchar(50) DEFAULT NULL,
  `roleDesc` varchar(50) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=5 DEFAULT CHARSET=utf8;



insert  into `sys_role`(`id`,`roleName`,`roleDesc`) values (1,'院长','负责全面工作'),(2,'研究员','课程研发工作'),(3,'讲师','授课工作'),(4,'助教','协助解决学生的问题');



DROP TABLE IF EXISTS `sys_user`;

CREATE TABLE `sys_user` (
  `id` bigint(20) NOT NULL AUTO_INCREMENT,
  `username` varchar(50) DEFAULT NULL,
  `email` varchar(50) DEFAULT NULL,
  `password` varchar(80) DEFAULT NULL,
  `phoneNum` varchar(20) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=4 DEFAULT CHARSET=utf8;



insert  into `sys_user`(`id`,`username`,`email`,`password`,`phoneNum`) values (1,'zhangsan','zhangsan@itcast.cn','123','13888888888'),(2,'lisi','lisi@itcast.cn','123','13999999999'),(3,'wangwu','wangwu@itcast.cn','123','18599999999');



DROP TABLE IF EXISTS `sys_user_role`;

CREATE TABLE `sys_user_role` (
  `userId` bigint(20) NOT NULL,
  `roleId` bigint(20) NOT NULL,
  PRIMARY KEY (`userId`,`roleId`),
  KEY `roleId` (`roleId`),
  CONSTRAINT `sys_user_role_ibfk_1` FOREIGN KEY (`userId`) REFERENCES `sys_user` (`id`),
  CONSTRAINT `sys_user_role_ibfk_2` FOREIGN KEY (`roleId`) REFERENCES `sys_role` (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;



insert  into `sys_user_role`(`userId`,`roleId`) values (1,1),(1,2),(2,2),(2,3);

;
;
;
;

项目结构

resources 下的配置文件

applicationContext.xml

spring-mvc.xml

jdbc.properties

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/test?characterEncoding=utf-8
jdbc.username=root
jdbc.password=root

log4j.properties

### direct log messages to stdout ###
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target=System.out
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n

### direct messages to file mylog.log ###
log4j.appender.file=org.apache.log4j.FileAppender
log4j.appender.file.File=c:/mylog.log
log4j.appender.file.layout=org.apache.log4j.PatternLayout
log4j.appender.file.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n

### set log levels - for more verbose logging change 'info' to 'debug' ###

log4j.rootLogger=info, stdout

web.xml





    
        CharacterEncodingFilter
        org.springframework.web.filter.CharacterEncodingFilter
        
            encoding
            utf-8
        
    
    
        CharacterEncodingFilter
        /*
    


    
        contextConfigLocation
        classpath:applicationContext.xml
    


    
        org.springframework.web.context.ContextLoaderListener
    


    
        DispatcherServlet
        org.springframework.web.servlet.DispatcherServlet
        
            contextConfigLocation
            classpath:spring-mvc.xml
        
        1
    
    
        DispatcherServlet
        /

java文件

controller

RoleController

package com.lzjtu.controller;

import com.lzjtu.domain.Role;
import com.lzjtu.service.RoleService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.ModelAndView;

import java.util.List;

@Controller
@RequestMapping("/role")
public class RoleController {

    @Autowired
    private RoleService roleService;

    @RequestMapping("/list")
    public ModelAndView list(){

        ModelAndView modelAndView = new ModelAndView();
        List roleList = roleService.list();
        // 设置模型
        modelAndView.addObject("roleList", roleList);
        // 设置视图
        modelAndView.setViewName("role-list");
        return modelAndView;
    }

    @RequestMapping("/save")
    public String save(Role role){
        roleService.save(role);
        return "redirect:/role/list";
    }
}

UserController

package com.lzjtu.controller;

import com.lzjtu.domain.Role;
import com.lzjtu.domain.User;
import com.lzjtu.service.RoleService;
import com.lzjtu.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.ModelAndView;

import javax.servlet.http.HttpSession;
import java.util.List;

@Controller
@RequestMapping("/user")
public class UserController {

    @Autowired
    private UserService userService;
    @Autowired
    private RoleService roleService;

    @RequestMapping("/login")
    public String login(String username, String password, HttpSession session){
        User user = userService.login(username, password);
        if(user != null){
            // 将user存储到session
            session.setAttribute("user", user);
            return "redirect:/index.jsp";
        }
        return "redirect:/login.jsp";
    }

    @RequestMapping("/del/{userId}")
    public String del(@PathVariable("userId") Long userId){
        userService.del(userId);
        return "redirect:/user/list";
    }

    @RequestMapping("/save")
    public String save(User user, Long[] roleIds){

        userService.save(user, roleIds);
        return "redirect:/user/list";
    }

    @RequestMapping("/saveUI")
    public ModelAndView saveUI(){

        ModelAndView modelAndView = new ModelAndView();
        List roleList = roleService.list();
        modelAndView.addObject("roleList", roleList);
        modelAndView.setViewName("user-add");
        return modelAndView;
    }

    @RequestMapping("/list")
    public ModelAndView list(){
        List userList = userService.list();

        ModelAndView modelAndView = new ModelAndView();
        modelAndView.addObject("userList", userList);
        modelAndView.setViewName("user-list");
        return modelAndView;
    }
}

dao

RoleDao.java

package com.lzjtu.dao;

import com.lzjtu.domain.Role;

import java.util.List;

public interface RoleDao {

    List findAll();
    void save(Role role);

    List findRoleByUserId(Long id);
}

UserDao.java

package com.lzjtu.dao;

import com.lzjtu.domain.User;

import java.util.List;

public interface UserDao {

    List findAll();

    Long save(User user);

    void saveUserRoleRel(Long id, Long[] roleIds);

    void delUserRoleRel(Long userId);

    void del(Long userId);

    User findByUsernameAndPassword(String username, String password);
}

impl

RoleDaoImpl.java

package com.lzjtu.dao.impl;

import com.lzjtu.dao.RoleDao;
import com.lzjtu.domain.Role;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;

import java.util.List;

public class RoleDaoImpl implements RoleDao {

    JdbcTemplate jdbcTemplate;

    public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
        this.jdbcTemplate = jdbcTemplate;
    }

    public List findAll() {
        String sql = "select * from sys_role";
        List roleList = jdbcTemplate.query(sql, new BeanPropertyRowMapper(Role.class));
        return roleList;
    }

    public void save(Role role) {
        String sql = "insert into sys_role value(?, ?, ?)";
        jdbcTemplate.update(sql, null, role.getRoleName(), role.getRoleDesc());
    }

    public List findRoleByUserId(Long id) {
        String sql = "select * from sys_user_role ur, sys_role r where ur.roleId=r.id and ur.userId=?";
        List roles = jdbcTemplate.query(sql, new BeanPropertyRowMapper(Role.class), id);
        return roles;
    }
}

UserDaoImpl.java

package com.lzjtu.dao.impl;

import com.lzjtu.dao.UserDao;
import com.lzjtu.domain.User;
import org.springframework.dao.EmptyResultDataAccessException;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.PreparedStatementCreator;
import org.springframework.jdbc.support.GeneratedKeyHolder;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.util.List;

public class UserDaoImpl implements UserDao {

    private JdbcTemplate jdbcTemplate;

    public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
        this.jdbcTemplate = jdbcTemplate;
    }

    public List findAll() {

        String sql = "select * from sys_user";
        List userList = jdbcTemplate.query(sql, new BeanPropertyRowMapper(User.class));
        return userList;
    }

    public Long save(final User user) {

        // 创建 PreparedStatementCreator
        PreparedStatementCreator creator = new PreparedStatementCreator() {
            public PreparedStatement createPreparedStatement(Connection connection) throws SQLException {
                // 使用原始的jdbc完成一个PreparedStatement的组建
                PreparedStatement preparedStatement = connection.prepareStatement("insert into sys_user values(?,?,?,?,?)", PreparedStatement.RETURN_GENERATED_KEYS);
                preparedStatement.setObject(1, null);
                preparedStatement.setString(2, user.getUsername());
                preparedStatement.setString(3, user.getEmail());
                preparedStatement.setString(4, user.getPassword());
                preparedStatement.setString(5, user.getPhoneNum());
                return preparedStatement;
            }
        };

        // 创建keyHolder
        GeneratedKeyHolder keyHolder = new GeneratedKeyHolder();

        jdbcTemplate.update(creator, keyHolder);

        // 获得生成的主键
        long userId = keyHolder.getKey().longValue();

//        String sql = "insert into sys_user values(?,?,?,?,?)";
//        jdbcTemplate.update(sql, null, user.getUsername(), user.getEmail(), user.getPassword(), user.getPhoneNum());

        return userId;  // 返回当前保存用户的id, 该id是数据库自动生成的
    }

    public void saveUserRoleRel(Long userId, Long[] roleIds) {

        String sql = "insert into sys_user_role values(?,?)";
        for (Long roleId: roleIds){
            jdbcTemplate.update(sql, userId, roleId);
        }
    }

    public void delUserRoleRel(Long userId) {
        String sql = "delete from sys_user_role where userId=?";
        jdbcTemplate.update(sql, userId);
    }

    public void del(Long userId) {
        String sql = "delete from sys_user where id=?";
        jdbcTemplate.update(sql, userId);
    }

    public User findByUsernameAndPassword(String username, String password) throws EmptyResultDataAccessException {

        String sql = "select * from sys_user where username=? and password=?";
        User user = jdbcTemplate.queryForObject(sql, new BeanPropertyRowMapper(User.class), username, password);
        return user;
    }
}

domain

Role.java

package com.lzjtu.domain;

public class Role {

    private Long id;
    private String roleName;
    private String roleDesc;

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getRoleName() {
        return roleName;
    }

    public void setRoleName(String roleName) {
        this.roleName = roleName;
    }

    public String getRoleDesc() {
        return roleDesc;
    }

    public void setRoleDesc(String roleDesc) {
        this.roleDesc = roleDesc;
    }

    @Override
    public String toString() {
        return "Role{" +
                "id=" + id +
                ", roleName='" + roleName + ''' +
                ", roleDesc='" + roleDesc + ''' +
                '}';
    }
}

User.java

package com.lzjtu.domain;

import java.util.List;

public class User {

    private Long id;
    private String username;
    private String email;
    private String password;
    private String phoneNum;

    // 当前用户具备哪些角色
    private List roles;

    public List getRoles() {
        return roles;
    }

    public void setRoles(List roles) {
        this.roles = roles;
    }

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public String getPhoneNum() {
        return phoneNum;
    }

    public void setPhoneNum(String phoneNum) {
        this.phoneNum = phoneNum;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", username='" + username + ''' +
                ", email='" + email + ''' +
                ", password='" + password + ''' +
                ", phoneNum='" + phoneNum + ''' +
                '}';
    }
}

interceptor

PrivilegeInterceptor.java

package com.lzjtu.interceptor;

import com.lzjtu.domain.User;
import org.springframework.web.servlet.HandlerInterceptor;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;

public class PrivilegeInterceptor implements HandlerInterceptor {

    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        // 判断用户是否登录 判断session中有没有 user
        HttpSession session = request.getSession();
        User user = (User) session.getAttribute("user");
        if(user == null){
            // 没有登录
            response.sendRedirect(request.getContextPath()+"/login.jsp");
            return false;
        }
        // 放行
        return true;
    }
}

service

RoleService.java

package com.lzjtu.service;

import com.lzjtu.domain.Role;

import java.util.List;

public interface RoleService {

    List list();
    void save(Role role);
}

UserService.java

package com.lzjtu.service;

import com.lzjtu.domain.User;

import java.util.List;

public interface UserService {

    List list();

    void save(User user, Long[] roleIds);

    void del(Long userId);

    User login(String username, String password);
}

impl

RoleServiceImpl.java

package com.lzjtu.service.impl;

import com.lzjtu.dao.RoleDao;
import com.lzjtu.domain.Role;
import com.lzjtu.service.RoleService;

import java.util.List;

public class RoleServiceImpl implements RoleService {

    public void setRoleDao(RoleDao roleDao) {
        this.roleDao = roleDao;
    }

    private RoleDao roleDao;

    public List list() {
        List roleList = roleDao.findAll();
        return roleList;
    }

    public void save(Role role) {
        roleDao.save(role);
    }
}

UserServiceImpl.java

package com.lzjtu.service.impl;

import com.lzjtu.dao.RoleDao;
import com.lzjtu.dao.UserDao;
import com.lzjtu.domain.Role;
import com.lzjtu.domain.User;
import com.lzjtu.service.UserService;
import org.springframework.dao.EmptyResultDataAccessException;

import java.util.List;

public class UserServiceImpl implements UserService {

    private UserDao userDao;
    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

    private RoleDao roleDao;
    public void setRoleDao(RoleDao roleDao) {
        this.roleDao = roleDao;
    }

    public List list() {

        List userList = userDao.findAll();
        // 封装userList中的每一个User的roles数据
        for (User user: userList){
            // 获得user的id
            Long id = user.getId();
            // 将id作为参数  查询当前userId对应的Role集合数据
            List roles = roleDao.findRoleByUserId(id);
            user.setRoles(roles);
        }
        return userList;
    }

    public void save(User user, Long[] roleIds) {
        // 第一步 向sys_user表中存储数据
        Long userId = userDao.save(user);

        // 第二步 向 sys_user_role 关系表中存储多条数据
        userDao.saveUserRoleRel(userId, roleIds);
    }

    public void del(Long userId) {

        // 删除 sys_user_role 关系表
        userDao.delUserRoleRel(userId);
        // 删除 sys_user 表
        userDao.del(userId);

    }

    public User login(String username, String password) {
        try {

            User user = userDao.findByUsernameAndPassword(username, password);
            return user;
        }catch (EmptyResultDataAccessException e){
            return null;
        }
    }
}

六、Spring练习

Java相关栏目本月热门文章