spring mvc后端实现过程

一、Spring mvc

1、controller

控制器层、处理用户的请求和响应，

1.1、LoginController01

@Controller
public class LoginController01 {
    @ResponseBody
    //配置请求
    @RequestMapping("/login.action")
    public String login(LoginVo loginVo) throws JsonProcessingException {
        //从字符串中读取JSON
        //ObjectMapper类是Jackson库的主要类。它称为ObjectMapper的原因是因为它将JSON映射到Java对象（反序列化），
        //或将Java对象映射到JSON（序列化）。它使用JsonParser和JsonGenerator的实例实现JSON实际的读/写。
        ObjectMapper objectMapper=new ObjectMapper();
        String json=objectMapper.writeValueAsString(loginVo);
        System.out.println(loginVo);
        return json;
    }
}

1. @Controller 注解
   @Controller 注解将 LoginController01 类标识为一个控制器，Spring MVC 会将该类中的方法映射为处理特定 HTTP 请求的处理器。

2. @ResponseBody 注解
   @ResponseBody 注解表示该方法的返回值会被直接写入 HTTP 响应体中，而不是解析为视图名。结合这段代码，它表示返回的 String（JSON 格式）将作为 HTTP 响应体返回给客户端。

3. @RequestMapping(“/login.action”) 注解
   @RequestMapping 注解用于将一个特定的 URL 映射到控制器中的方法。在这里，/login.action 表示当客户端发送这个 URL 请求时，会调用 login() 方法处理请求。

4. LoginVo loginVo 参数
   LoginVo 可能是一个自定义的类，表示用户登录时提交的数据。Spring MVC 会根据请求中的参数，将请求参数映射到 LoginVo 对象中（如表单数据）。

5. ObjectMapper 类
   代码中使用了 Jackson 库的 ObjectMapper 类，这是一个用于处理 JSON 的核心类。它负责在 Java 对象和 JSON 之间进行转换：
   writeValueAsString(loginVo)：将 loginVo 对象序列化为 JSON 字符串。
   objectMapper.writeValueAsString(loginVo) 返回的 json 就是序列化后的 JSON 字符串。

6. System.out.println(loginVo)
   输出登录数据对象的内容到控制台，便于调试。

7. LoginController 继承 AbstractController
   AbstractController 是 Spring 提供的一个基类，通常用于处理 Web 请求。通过继承它，你可以自定义自己的控制器行为。
   该控制器通过实现 handleRequestInternal() 方法来处理 HTTP 请求。这个方法会处理来自客户端的请求并返回视图信息。

8. 依赖注入 (@Autowired)
   @Autowired 注解用于自动注入依赖。这里将 LoginService 注入到控制器中，说明 LoginController 依赖于 LoginService，并且 LoginService 会在 ApplicationContext 中被自动注入。

1.2、LoginController

/继承controller成为一个servlet
public class LoginController extends AbstractController {
    //定义了一个LoginService类型的变量
    @Autowired
    private LoginService loginService;
    @Override
    protected ModelAndView handleRequestInternal(HttpServletRequest request, HttpServletResponse response) throws Exception {
        //获得参数
        String name=request.getParameter("number");
        String password=request.getParameter("password");
        //封装
        LoginVo loginVo=new LoginVo(name,password);
        //调用类方法赋值给i
        int i=loginService.login(loginVo);


//        如果翻译过来就是”模型和视图“，可以理解成MVC架构中的”M“和”V“，其中包含”Model“和”view“两部分，主要功能是：
//        设置转向地址
//        将底层获取的数据进行存储（或者封装）
//        最后将数据传递给View
        //创建ModelAndView对象
        ModelAndView modelAndView=new ModelAndView();
        //向modelAndView对象中添加数据
        modelAndView.addObject("msg",i);
        //设置逻辑视图名
        modelAndView.setViewName("jsp/login");
        //返回modelAndView对象
        return modelAndView;
    }
}

这段代码展示了一个 Spring MVC 的控制器 LoginController，继承了 AbstractController，并且通过 ModelAndView 返回模型和视图，属于传统的 Spring MVC 编程风格。以下是对这段代码的详细分析：

1. LoginController 继承 AbstractController
   AbstractController 是 Spring 提供的一个基类，通常用于处理 Web 请求。通过继承它，你可以自定义自己的控制器行为。
   该控制器通过实现 handleRequestInternal() 方法来处理 HTTP 请求。这个方法会处理来自客户端的请求并返回视图信息。
2. 依赖注入 (@Autowired)
   @Autowired 注解用于自动注入依赖。这里将 LoginService 注入到控制器中，说明 LoginController 依赖于 LoginService，并且 LoginService 会在 ApplicationContext 中被自动注入。

@Autowired
private LoginService loginService;
LoginService 是服务层的一个类，负责处理业务逻辑，特别是在这里用于验证登录信息。

3. handleRequestInternal() 方法
   handleRequestInternal() 是处理 HTTP 请求的核心方法。该方法被 Spring 框架自动调用，用于处理客户端请求。它接收两个参数：
   HttpServletRequest：表示客户端的 HTTP 请求对象，可以从中获取请求参数。
   HttpServletResponse：表示服务器对客户端的 HTTP 响应对象。
   在这个方法中：
   通过 request.getParameter(“number”) 和 request.getParameter(“password”) 获取用户通过表单提交的用户名和密码。
   将获取的用户名和密码封装到 LoginVo 对象中，类似于 DTO（数据传输对象）的设计。
   java
   复制代码
   String name = request.getParameter(“number”);
   String password = request.getParameter(“password”);
   LoginVo loginVo = new LoginVo(name, password);
4. 调用 LoginService 进行业务处理
   LoginService 中应该有一个 login() 方法来处理登录逻辑。这里调用 loginService.login(loginVo)，并将结果存储在 int i 变量中。

int i = loginService.login(loginVo);
根据业务逻辑，loginService.login(loginVo) 可能返回一个整数值 i，这个值可能代表不同的登录结果，比如：

0：登录失败（用户名或密码错误）
1：登录成功
5. ModelAndView 类
ModelAndView 是 Spring MVC 中的核心类，用于封装模型数据和视图信息。可以理解为它在 MVC 架构中承担了将模型数据传递给视图的责任。

该方法创建了一个 ModelAndView 对象，用来：

添加模型数据：通过 modelAndView.addObject(“msg”, i)，将登录结果 i 作为消息存储到模型中，以便在视图（如 JSP）中使用。
设置视图名称：通过 modelAndView.setViewName(“jsp/login”)，指定返回的视图为 jsp/login，即页面文件路径为 WEB-INF/jsp/login.jsp。

ModelAndView modelAndView = new ModelAndView();
modelAndView.addObject(“msg”, i);
modelAndView.setViewName(“jsp/login”);
6. 返回 ModelAndView 对象
handleRequestInternal() 方法最终返回 ModelAndView 对象给 Spring 容器，Spring 会根据视图名称去查找相应的 JSP 文件，并将模型数据传递给视图层以进行渲染。

return modelAndView;
7. 业务流程概述
整体的业务流程如下：

用户发送一个包含 number 和 password 的登录请求。
LoginController 处理该请求，调用 loginService 验证用户信息。
loginService 返回验证结果（如成功或失败）。
LoginController 将结果存储在 ModelAndView 中，并设置要跳转的视图（JSP 页面）。
最后，Spring MVC 渲染 JSP 页面，将模型中的数据显示给用户。

2、service

业务逻辑层

2.1、LoginService

public interface LoginService {
    public int login(LoginVo loginVo);
    public LoginVo all(LoginVo loginVo);
    public int insert(LoginVo loginVo);
    public int update(String name,String oldpassword,String newpassword);
    public int delete(LoginVo loginVo);
    public LoginVo loginone(String name,String password);

}

这个 LoginService 接口定义了一个服务层的接口，用于处理登录功能和其他用户信息相关的业务逻辑。通常，接口是用于定义业务逻辑的抽象层，实际的实现类会提供具体的业务实现。让我们分析一下每个方法的用途：

1. public int login(LoginVo loginVo);
   功能：用于处理用户登录逻辑。
   参数：接收一个 LoginVo 对象，其中包含用户的登录信息（如用户名和密码）。
   返回值：返回一个 int 类型，通常用于表示登录结果：
   1 表示登录成功。
   0 表示登录失败（可能是用户名或密码错误）。
2. public LoginVo all(LoginVo loginVo);
   功能：可能用于获取某个用户的所有信息。
   参数：接受一个 LoginVo 对象，可能根据 loginVo 中的信息（如用户名）去查询完整的用户信息。
   返回值：返回一个 LoginVo 对象，表示查询到的用户完整信息。
3. public int insert(LoginVo loginVo);
   功能：用于插入一个新的用户记录，通常是用户注册时调用的操作。
   参数：接收一个 LoginVo 对象，其中包含需要插入的用户信息。
   返回值：返回一个 int，用于表示操作的结果：
   1 表示插入成功。
   0 表示插入失败。

这个 LoginService 接口定义了几个用于用户管理的核心方法，包括登录验证、用户信息查询、插入（注册）、更新（修改密码）、删除等功能。
具体的实现类需要实现这些方法，处理具体的业务逻辑，比如连接数据库、执行增删改查操作。
每个方法的返回值主要用于表示操作的成功或失败，尤其是增删改查操作中通常会用 int 表示操作结果，而在获取用户信息时返回 LoginVo 对象。

LoginImplements 类是 LoginService 接口的实现类，它通过数据库查询用户信息并提供登录验证的功能。让我们逐步分析代码并理解其作用：

2.1、LoginInimplements

@Service
public class LoginImplements implements LoginService{
    //有数据返回1否则0
    @Autowired
    LoginMapper mapper;
    @Override
    public int login(LoginVo loginVo) {
       LoginVo loginVo1=mapper.selectlogin(loginVo);
       if (loginVo1!=null){
           return 1;
       }else {
            return 0;
       }

        /**
        if(loginVo.getName().equals("admin")&&loginVo.getPassword().equals("123456")){
            return 1;
        }else
            return 0;
    }
         **/
    }
    //通过账号密码查询整个登入信息
    @Override
    public LoginVo all(LoginVo loginVo) {
        LoginVo loginVo1=mapper.selectlogin(loginVo);
        if (loginVo1!=null){
            return loginVo1;
        }else {
            return null;
        }
    }
    //插入
    @Override
    public int insert(LoginVo loginVo) {
        return mapper.insertlogin(loginVo);
    }
    /**
     *
     * @param name
     * @param oldpassword
     * @param newpassword
     * @return 1成功 2旧密码不对 0修改失败
     */
    //通过账号修改密码
    @Override
    public int update(String name,String oldpassword,String newpassword) {
        //判断旧密码是否正确
        LoginVo loginVo=new LoginVo(name,oldpassword);
        LoginVo temp=mapper.selectlogin(loginVo);
        if(temp!=null){
            //密码正确
            LoginVo loginVo1=new LoginVo(name,newpassword);
            int count=mapper.updatelogin(loginVo1);
            return count;
        }else {
            return 2;
        }
    }
    //通过账号密码删除账户
    @Override
    public int delete(LoginVo loginVo) {
        return mapper.deletelogin(loginVo);
    }
    //查询所有账户
    @Override
    public LoginVo loginone(String name,String password) {
        LoginVo loginVo2=mapper.selectloginone(name,password);
        return  loginVo2;

    }
}

1. @Service 注解
   @Service 是 Spring 中的一个注解，表示该类是一个服务层组件。Spring 会将它作为一个 bean 管理，方便在需要的地方进行注入。
   在这个例子中，LoginImplements 实现了 LoginService 接口，并且通过 @Autowired 自动注入了 LoginMapper，用于数据库操作。
2. @Autowired 注解
   @Autowired 注解用于自动注入 Spring 管理的 bean。
   在这里，LoginMapper 是自动注入的，意味着 Spring 会将 LoginMapper 接口的实现类注入到 LoginImplements 类中。LoginMapper 应该是一个 MyBatis 的 Mapper，用于执行数据库查询操作。
3. public int login(LoginVo loginVo) 方法
   功能：通过 loginVo 中的用户名和密码去数据库查询，如果查询到有对应的记录，则返回 1，表示登录成功；否则返回 0，表示登录失败。

逻辑：

调用 mapper.selectlogin(loginVo) 查询数据库，检查是否存在该用户。
如果 loginVo1 不为 null，表示查询到了匹配的用户，返回 1。
否则返回 0，表示登录失败。

3、dao

数据访问层用于对数据库的交互

3.1、LoginMapper

/dao层注解
@Repository
public interface LoginMapper {
    /**
     *查询信息表数据
     * @param loginVo
     * @return
     */
    public LoginVo selectlogin(LoginVo loginVo);
    /**
     *添加登录信息表数据
     * @param loginVo 添加数据用户名密码
     * @return 影响数据操作的行数1 成功，0失败
     */
    public int insertlogin(LoginVo loginVo);


    public int updatelogin(LoginVo loginVo);

    /**
     * 删除数据类型
     * @param loginVo 删除数据用户账号密码
     * @return 影响数据的操作行数，成功为1 失败为0
     */
    public  int deletelogin(LoginVo loginVo);
    /**
     *查询信息表数据
     * @param可以在mybaties中找到
     * @return
     */
    public LoginVo selectloginone(@Param("name") String name,@Param("password")  String password);

    public List<LoginVo> selectloginall();

}

LoginMapper 是一个 DAO（数据访问对象）接口，它通过 MyBatis 或其他 ORM 框架来执行数据库的 CRUD（增删改查）操作。在这个接口中，通过定义方法来与数据库进行交互。注解 @Repository 表示它是持久层组件，Spring 会将其作为一个 bean 管理。

让我们详细分析每个方法的作用及其注释。

1. @Repository 注解
   @Repository 是 Spring 的一个注解，标识该类是 DAO 层（持久层）组件。Spring 会自动扫描并将其注册为一个 bean。
   它表明该接口的实现类是与数据库交互的层次。
2. 方法分析
3. public LoginVo selectlogin(LoginVo loginVo);
   功能：根据传入的 loginVo 对象中的信息（如用户名和密码）查询数据库，返回用户信息。
   参数：LoginVo 对象，包含了用户的登录信息（例如用户名、密码）。
   返回值：返回一个 LoginVo 对象，表示查询到的用户。如果查询不到对应的记录，可能会返回 null。
4. public int insertlogin(LoginVo loginVo);
   功能：将一个新的用户记录插入到数据库中，通常用于用户注册。
   参数：LoginVo 对象，包含要插入的用户信息（如用户名、密码）。
   返回值：返回一个 int，表示影响的行数。通常：
   1 表示插入成功。
   0 表示插入失败。
5. public int updatelogin(LoginVo loginVo);
   功能：更新数据库中的用户信息（如修改密码、修改用户资料等）。
   参数：LoginVo 对象，包含需要更新的信息。
   返回值：返回一个 int，表示影响的行数。通常：
   1 表示更新成功。
   0 表示更新失败。

3.1、LoginMapper.xml

<mapper namespace="com.example.text.dao.LoginMapper">
<!--    增删改查-->
<select id="selectlogin" parameterType="LoginVo" resultType="LoginVo">
    select *from login where name =#{name} and password=#{password};
</select>

    <insert id="insertlogin" parameterType="LoginVo">
        insert into login (name,password) values (#{name},#{password});
    </insert>
    <update id="updatelogin" parameterType="LoginVo">
        update login set password=#{password} where name=#{name};
    </update>
    <delete id="deletelogin" parameterType="LoginVo">
        delete from login where password=#{password}
    </delete>
    <select id="selectloginone" parameterType="String" resultType="LoginVo">
        select *from login where name =#{name} and password=#{password};
    </select>
    <select id="selectloginall"  resultType="LoginVo">
        select *from login;
    </select>
</mapper>

4、实体类

@Component
public class LoginVo {
    private String name;
    private String password;
    public LoginVo() {

    }

    public LoginVo(String name, String password) {
        this.name = name;
        this.password = password;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getPassword() {
        return password;
    }

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