毕业实习-ssm框架搭建之增删改查的实现

ssm框架搭建之增删改查的实现

ssm框架编写和执行顺序

(个人理解向)
编写顺序：首先先编写model；然后是dao；mapper;service；serviceImpl;controller;最后就是表现层，JSP页面的代码修改。（主要是方法的调用，参数名的修改）
执行顺序：首先是index.JSP界面的方法调用，然后调用界面传参，之后是controller→serviceImpl→dao。

ssm框架增删改查的实现

1.首先是bean层的user;

package com.zhongruan.bean;
/**
 * 实体类模型 - User
 */
public class User {
    private  int id; //用户Id
    private  String username; // 用户名
    private  String userpassword; //密码
    //get and set
    //User user = new User();   user.get/serID
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getUsername() {
        return username;
    }
    public void setUsername(String username) {
        this.username = username;
    }
    public String getUserpassword() {
        return userpassword;
    }
    public void setUserpassword(String userpassword) {
        this.userpassword = userpassword;
    }
    //构造方法 - User user = new User("","","")；
    public User(int id, String name, String password) {
        this.id = id;
        this.username = name;
        this.userpassword = password;
    }
    public User() {
    }
    //toString
    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", name='" + username + '\'' +
                ", password='" + userpassword + '\'' +
                '}';
    }
}

2.然后是dao层：

3.接下来是service层（这个和dao层中建立的都是接口）

4.然后是sevicesImpl

@Service
public class UserServiceImpl implements UserService {

    @Autowired
    private UserDao userDao;

    // a=b; b=c; a=c
    @Override
    public List<User> findAllUser() {
        return userDao.findAllUser();
    }

    @Override
    public void addUser(User user) {
        userDao.addUser(user);
    }

    @Override
    public User findUpdUserById(int id) {
        return userDao.fingUpdUserById(id);
    }

    @Override
    public void updUserById(User user) {
        userDao.updUserById(user);
    }

    @Override
    public void delUserById(int id) {
        userDao.delUserById(id);
    }

    @Override
    public List<User> findUserByvague(String username) {
        return userDao.findUserByvague(username);
    }

}

5.然后是controller

@RequestMapping("user")
public class UserController {

    @Autowired
    private UserService userService;

    //查询所有
    @RequestMapping("/findAllUser.do")
    public ModelAndView findAllUser(){
        //调用Service 方法，去查询得到结果
        List<User> userList = userService.findAllUser();
        //为了进行返回值的传递，需要把返回值封装到Spring内置到ModeAndView
        ModelAndView mv = new ModelAndView();
        mv.addObject("userList",userList);
        //user-List.jsp
        mv.setViewName("user-list");
        return mv;
    }

    // 增加  java.lang.String
    @RequestMapping("/addUser.do")
    public  String addUser(User user){
        // 调用Service里的方法，得到结果
        userService.addUser(user);

        return "redirect:findAllUser.do";
    }

    //修改前的查询操作
    @RequestMapping("/findUpdUserById.do")
    public  ModelAndView findUpdUserById(int id){
        //1.调用Service方法，得到结果
        User user = userService.findUpdUserById(id);
//        System.out.println("得到的结果为："+user);
        //2.实例化
        ModelAndView mv = new ModelAndView();
        mv.addObject("user",user);
        mv.setViewName("user-update");
        return mv;
    }

    //修改
    @RequestMapping("/updUserById.do")
    public String updUserById(User user){
        userService.updUserById(user);
        return "redirect:findAllUser.do";
    }

    //删除
    @RequestMapping("/delUserById.do")
    public String delUserById(int id)
    {
        userService.delUserById(id);
        return "redirect:findAllUser.do";
    }

    //模糊查询
    @RequestMapping("/findUserByvague.do")
    public ModelAndView findUserByvague(String username){
        List<User> userList = userService.findUserByvague(username);
        ModelAndView mv = new ModelAndView();
        mv.addObject("userList",userList);
        mv.setViewName("user-list");
        return  mv;
    }

}

6.sql语句

<!--  查询全部  -->
<select id="findAllUser"  resultType="com.zhongruan.bean.User">
    select * from tb_user
</select>

<!--增加-->
<insert id="addUser" parameterType="com.zhongruan.bean.User">
    insert into tb_user(id,username,userpassword) values(#{id},#{username},#{userpassword})
</insert>

<!--修改前的查询  -->
<select id="fingUpdUserById" parameterType="java.lang.Integer" resultType="com.zhongruan.bean.User">
    select * from tb_user where id=#{id}
</select>

<!--修改  -->
<update id="updUserById" parameterType="com.zhongruan.bean.User">
    update tb_user set username=#{username},userpassword=#{userpassword} where id=#{id}
</update>

<!--删除   -->
<delete id="delUserById" parameterType="java.lang.Integer">
    delete from tb_user where id=#{id};
</delete>

<!--模糊查询-->
<select id="findUserByvague" resultType="com.zhongruan.bean.User">
    select * from tb_user where username like CONCAT(CONCAT('%',#{username}),'%') or userpassword like '%${_parameter}%'
</select>

注意点

这里对其中的模糊查询解释下，like 中后面跟的内容为
CONCAT(CONCAT(’%’,#{username}),’%’) （CONCAT为连接）
‘%${_parameter}%’ _parameter 针对所有String ,注意，只要是String类型，就是_parameter。

还要注意，ssm框架中搭建的传参等都是user的实例化（这里以user为例），要与数据库对接上不出错，两边的命名要求一样。

知识点

重定向与请求转发的区别

请求转发：
request.getRequestDispatcher().forward();
重定向：
response.sendRedirect();
例如：
请求转发：
request.getRequestDispatcher("/student_list.jsp").forward(request,response);
重定向：
response.sendRedirect(request.getContextPath + “/student_list.jsp”)
1、转发是在服务器端完成的，重定向是在客户端发生的；
2、转发的速度快，重定向速度慢；
3、转发是同一次请求，重定向是两次请求；
4、转发地址栏没有变化，重定向地址栏有变化；
5、转发必须是在同一台服务器下完成，重定向可以在不同的服务器下完成。
参考：https://www.cnblogs.com/yinyl/p/8116490.html

get post 的区别

GET 和 POST 只是 HTTP 协议中两种请求方式（异曲同工），而 HTTP 协议是基于 TCP/IP 的应用层协议，无论 GET 还是 POST，用的都是同一个传输层协议，所以在传输上，没有区别。
报文格式上，不带参数时，最大区别就是第一行方法名不同, 仅仅是报文的几个字符不同而已POST 方法请求报文第一行是这样的 POST /url HTTP/1.1 GET 方法请求报文第一行是这样的 GET /url HTTP/1.1。
带参数时，在约定中，GET 方法的参数应该放在 url 中，POST 方法参数应该放在 body 中。

override和overload 的异同

override（重写）：
1.方法名、参数、返回值不同。
2.子类方法不能缩小父类方法的访问权限。
3.子类方法不能抛出比父类方法更多的异常（但子类方法可以不抛异常）
4.存在于父类和子类之间。
5.方法被定义为final时不能被重写。
overload（重载）：
1.参数类型、个数、顺序至少一种不相同。
2.不能重载只有返回值不同的方法名。
3.存在于父类和子类、同类中。