[1024 programmer's section] RestFul,mvc interceptor, SSM basic integration - learning notes

Posted by installer69 on Sun, 24 Oct 2021 05:26:38 +0200

1. Spring MVC file upload

1.1 multi file upload

  • Multi file upload is similar to single file upload

  • Steps:

    • Form:

      <form method="post" enctype="multipart/form-data">
	<!--Provide multiple input，Multiple uploaded files can be selected-->
	<input type="file" name="images" />
	<input type="file" name="images" />  
</form>

    • Controllers: method parameters

      public String upload(List<MultipartFile> images) {
    
}

1.2 JSON

  • Syntax:

    //object
var obj = {
	key:value,
	....
}

//array
var arr = [element,....]

  • The underlying spring mvc uses jackson Java objects and JSON data transformation

    • Transform core annotation

      //Request: JSON data -- > java object
@RequestBody ，Modifier in method parameters

//Response: Java object -- > JSON data
@ResponseBody，1)The current method before the modifier method is converted to JSON；2)Before decorating the class, all methods in the class return JSON.

    • Data qualification annotation

      //ignore
@JsonIgnore

//Date conversion
@JSONFormat(pattern="yyyy-MM-dd HH:mm:ss",timezone="GMT+8")

2. RESTFul

2.1 what is RESTFul

  • RESTFul programming is a style, not a protocol.

  • Interpretation of HTTP protocol (landing scheme) and landing of request mode

    http There are 7 protocols in total, 4 common and 2 longest
get
post
put
delete

  • RESTFul specifies the operation of the server program.

    • Each operation consists of: request path + request mode. (one path can complete different operations due to different request modes)
    • Data transmission mode: JSON data
    // Traditional development path
 Query: http://localhost:8080/user/selectAll.action
 add to: http://localhost:8080/user/addUser.action
 Modification: http://localhost:8080/user/updateUser.action
 Delete: http://localhost:8080/user/deleteUser.action

// RESTFul style path
 Query: get    http://localhost:8080/user/
Details: get    http://localhost:8080/user/123
 add to: post   http://localhost:8080/user/
Modification: put    http://localhost:8080/user/
Delete: delete http://localhost:8080/user/123

2.2 use

2.2.1 steps

  • Step 1: create a new project (day15_mvc_restful)

  • Step 2: import jar packages: spring, spring mvc, jackson, mybatis

  • Step 3: configure the class,

    • spring mvc configuration
    • Start the configuration class. The front-end controller has no extension and is changed from *. action to/

  • Step 4: write controller to complete addition, deletion, modification and query

    • 4.1 class level:

      @Controller ,@ResponseBody		
//-->Synthetic injection 
@RestController

    • 4.2 method level: @ RequestMapping(value = "path", method=RequestMethod.GET /POST/PUT/DELETE)

      //Traditional writing
@RequestMapping(value="route", method=RequestMethod.GET /POST/PUT/DELETE)

//-->Simplified writing of various request modes
@GetMapping
@PostMapping
@PutMapping
@DeleteMapping

@PathVariable		//Used to obtain path parameters

    • 4.3 method return value

      //According to the constraints and based on the RESTFul style, it is recommended to use the ResponseEntity type for the return value of the method
// ResponseEntity is used to encapsulate return value information, including status code
// Return 200 status code, ResponseEntity.ok("added successfully");
// Other status codes, new responseentity < > ("added successfully", HttpStatus.UNAUTHORIZED)

2.2.2 realization

  • Configuration class

[the external chain picture transfer fails. The source station may have an anti-theft chain mechanism. It is recommended to save the picture and upload it directly (img-jvehtbtx-163461553987) (assets / image-20211014152155234. PNG)]

  • controller
package com.czxy.rest.controller;

import com.czxy.rest.domain.User;
import io.swagger.models.Response;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

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

/**
 * @author Maynor
 * Maynor Big data Road
 */
@RestController
@RequestMapping("/user")
public class UserController2 {
    /**
     * Query all
     * @return
     */
    //Equivalent @ RequestMapping(method = RequestMethod.GET)
    @GetMapping
    public ResponseEntity<List<User>> list() {
        List<User> list = new ArrayList<>();
        list.add(new User(1,"jack","1234", new Date()));
        list.add(new User(2,"shredded meat","6666", new Date()));
        list.add(new User(3,"tom","loverose", new Date()));

        return ResponseEntity.ok(list);
    }

    /**
     * Add user
     * @param user
     * @return
     */
    @PostMapping(produces = "application/json;charset=UTF-8")
    public ResponseEntity add(@RequestBody User user) {
        System.out.println(user);
        return ResponseEntity.ok("Added successfully");
    }

    /**
     *
     * @param user
     * @return
     */
    @PutMapping
    public ResponseEntity<String> update(@RequestBody User user) {
        System.out.println(user);
        return ResponseEntity.ok("update success");
    }

    /**
     * delete
     * @param userId
     * @return
     */
    @DeleteMapping("/{id}")
    public ResponseEntity<String> delete(@PathVariable("id") String userId ) {
        System.out.println(userId);
        return ResponseEntity.ok("delete success");
    }

}

3. spring mvc interceptor

3.1 general

  • The spring mvc interceptor is equivalent to a java web filter
  • Intercept or process during processor execution

[the external chain picture transfer fails. The source station may have an anti-theft chain mechanism. It is recommended to save the picture and upload it directly (img-vicjwlmq-16346153990) (assets / image-20211014160606073. PNG)]

preHandler Interceptor pre-processing method, if returned true Continue if returned false，Indicates being intercepted.
postHandler Interceptor processing mode, controller When execution is complete, the processing method is executed.
afterCompletion The completion method is triggered when the view rendering is completed.

3.2 introduction cases

  1. Environment: project, jar package, configuration class

  2. Test program: controller, jsp

  3. Write interceptors to verify the process

  4. Write configuration file

  5. Environment: project, jar package, configuration class

    [the external chain picture transfer fails. The source station may have an anti-theft chain mechanism. It is recommended to save the picture and upload it directly (img-bv8kn9bj-163461545993) (assets / image-20211014164558131. PNG)]

  6. Test program: controller, jsp

    [the external chain picture transfer fails. The source station may have an anti-theft chain mechanism. It is recommended to save the picture and upload it directly (img-rtt6jwy5-16346153995) (assets / image-20211014164615194. PNG)]

    package com.czxy.inter.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

/**
 * @author Maynor
 * Maynor Big data Road
 */
@Controller
@RequestMapping("/user")
public class UserController {

    @RequestMapping("/selectAll")
    public String selectAll() {
        System.out.println("2 controller-->selectAll");
        return "list";
    }
}


    <%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
    Query results
    <%
        System.out.println("4 jsp output");
    %>
</body>
</html>

  7. Write interceptors to verify the process

    package com.czxy.inter.interceptor;

import org.springframework.stereotype.Component;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

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

/**
 * @author Maynor
 * Maynor Big data Road
 */
@Component
public class MyInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("1 Before interception");
        //Release
        return true;
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("3 In execution");
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("5 Final completion");
    }
}

  8. Write the configuration file and spring mvc configuration class. You need to implement the WebMvcConfigurer interface and re addInterceptors method

    package com.czxy.inter.config;

import com.czxy.inter.interceptor.MyInterceptor;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.converter.StringHttpMessageConverter;
import org.springframework.web.servlet.config.annotation.*;
import org.springframework.web.servlet.view.InternalResourceViewResolver;

import javax.annotation.Resource;
import java.nio.charset.Charset;

/**
 * @author Maynor
 * Maynor Big data Road
 */
@Configuration      //Configuration class
@ComponentScan(basePackages = {"com.czxy.inter.controller","com.czxy.inter.interceptor"})
@EnableWebMvc
public class SpringMVCConfig implements WebMvcConfigurer {

    @Resource
    private MyInterceptor myInterceptor;

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        InterceptorRegistration interceptorRegistration1 = registry.addInterceptor(myInterceptor);
        interceptorRegistration1.addPathPatterns("/**");
    }


    /**
     * view resolver 
     * @return
     */
    @Bean
    public InternalResourceViewResolver viewResolver() {
        InternalResourceViewResolver viewResolver = new InternalResourceViewResolver();
        // prefix
        viewResolver.setPrefix("/WEB-INF/pages/");
        // suffix
        viewResolver.setSuffix(".jsp");
        return viewResolver;
    }

}

3.3 multiple interceptors

  • Execution process

    [the external chain picture transfer fails. The source station may have an anti-theft chain mechanism. It is recommended to save the picture and upload it directly (img-awrte3ri-16346153996) (assets / image-20211014170419405. PNG)]

  • The order of multi interceptor interception is the order configured in the configuration class.

4. SSM integration: case

4.1 requirements

  • User's addition, deletion, modification and query
    • SSM: spring mvc ,spring,mybatis
    • view: jsp (non key)

4.2 environment construction

  • Project Name: day15_ssm_ums

  • Database: existing data

    # Create database
CREATE DATABASE ssm_db2;
# Use database
USE ssm_db2;
# 1.1 create user table
CREATE TABLE `user` (
  `uid` VARCHAR(32) NOT NULL,
  `username` VARCHAR(20) DEFAULT NULL,	#user name
  `password` VARCHAR(32) DEFAULT NULL,	#password
  `name` VARCHAR(20) DEFAULT NULL,		#nickname
  `email` VARCHAR(30) DEFAULT NULL,		#E-mail
  `telephone` VARCHAR(20) DEFAULT NULL,	#Telephone
  `birthday` DATE DEFAULT NULL,			#birthday
  `sex` VARCHAR(10) DEFAULT NULL,		#Gender
  `state` INT(11) DEFAULT 0,			#Status: 0 = inactive, 1 = activated
  `code` VARCHAR(64) DEFAULT NULL,		#Activation code
  PRIMARY KEY (`uid`)
) ;
# 1.2 initialize user default data
INSERT INTO `user` VALUES ('u001','jack','1234','jack','jack@czxy.com','13612345678','2015-11-04','male',0,NULL);
INSERT INTO `user` VALUES ('u002','rose','1234','shredded meat','rose@czxy.com','13612345679','2015-11-05','female',0,NULL);
INSERT INTO `user` VALUES ('373eb242933b4f5ca3bd43503c34668b','ccc','ccc','aaa','bbb@store.com','15723689921','2015-11-04','male',0,'9782f3e837ff422b9aee8b6381ccf927bdd9d2ced10d48f4ba4b9f187edf7738'),('3ca76a75e4f64db2bacd0974acc7c897','bb','bb','Zhang San','bbb@store.com','15723689921','1990-02-01','male',0,'1258e96181a9457987928954825189000bae305094a042d6bd9d2d35674684e6'),('62145f6e66ea4f5cbe7b6f6b954917d3','cc','cc','Zhang San','bbb@store.com','15723689921','2015-11-03','male',0,'19f100aa81184c03951c4b840a725b6a98097aa1106a4a38ba1c29f1a496c231'),('c95b15a864334adab3d5bb6604c6e1fc','bbb','bbb','Lao Wang','bbb@store.com','15712344823','2000-02-01','male',0,'71a3a933353347a4bcacff699e6baa9c950a02f6b84e4f6fb8404ca06febfd6f'),('f55b7d3a352a4f0782c910b2c70f1ea4','aaa','aaa','Xiao Wang','aaa@store.com','15712344823','2000-02-01','male',1,NULL);

  • Import jar package

    • spring,spring mvc
    • Integration of mybatis and spring
    • druid connection pool
    • jsp jstl (Standard Tag Library)

4.3 import configuration class

  • Create corresponding directory structure

    [the external chain picture transfer fails. The source station may have an anti-theft chain mechanism. It is recommended to save the picture and upload it directly (img-twfb0gpl-16346153997) (assets / image-20211014172230389. PNG)]

4.3.1 MyBatis configuration class

package com.czxy.ssm.config;

import com.github.pagehelper.PageHelper;
import org.apache.ibatis.plugin.Interceptor;
import org.apache.ibatis.session.Configuration;
import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.springframework.context.annotation.Bean;
import tk.mybatis.spring.mapper.MapperScannerConfigurer;

import javax.sql.DataSource;
import java.util.Properties;

public class MyBatisConfiguration {
	/**
	 * Configure session factory
	 * @param dataSource
	 * @return
	 * @throws Exception
	 */
	@Bean
	public SqlSessionFactory sqlSessionFactory(DataSource dataSource) throws Exception{
		//1 create factoryBean
		SqlSessionFactoryBean factoryBean = new SqlSessionFactoryBean();
		//2 setting data
		// 2.1 data source 
		factoryBean.setDataSource(dataSource);
		
		// 2.2 hump naming
		Configuration configuration = new Configuration();
		configuration.setMapUnderscoreToCamelCase(true);
		factoryBean.setConfiguration(configuration);
		
		// 2.3 paging plug-in
		Properties props = new Properties();
		// Set dialect
		props.setProperty("dialect", "mysql");
		// count query while paging
		props.setProperty("rowBoundsWithCount", "true");
		// Paging rationalization parameters: when pagenum < = 0, the first page will be queried, and when pagenum > pages (exceeds the total), the last page will be queried
		props.setProperty("reasonable", "true");

//		PageInterceptor pageInterceptor = new PageInterceptor();
//		pageInterceptor.setProperties(props);
		PageHelper pageHelper = new PageHelper();
		pageHelper.setProperties(props);

		factoryBean.setPlugins(new Interceptor[] {pageHelper});
		
		//3. Obtain the corresponding information through factorybean
		return factoryBean.getObject();
	}
	/**
	 * Mapping scanner
	 * @return
	 */
	@Bean
	public MapperScannerConfigurer mapperScannerConfigurer(){
		//1 create
		MapperScannerConfigurer mapperScanner = new MapperScannerConfigurer();
		//2 setting package
		mapperScanner.setBasePackage("com.czxy.ssm.mapper");
		
		return mapperScanner;
	}

}

4.3.2 Spring configuration class

  • Data source profile

    jdbc.driver=com.mysql.cj.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/ssm_db2
jdbc.username=root
jdbc.password=1234

  • Configuration class

package com.czxy.ssm.config;

import com.alibaba.druid.pool.DruidDataSource;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.PropertySource;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.transaction.annotation.EnableTransactionManagement;

import javax.sql.DataSource;

@ComponentScan(basePackages="com.czxy.ssm.service")
@PropertySource("classpath:db.properties")
@EnableTransactionManagement
public class SpringConfiguration {
	/**
	 * Get the contents in the properties file and inject the corresponding variables
	 */
	@Value("${jdbc.driver}")
	private String driver;
	
	@Value("${jdbc.url}")
	private String url;
	
	@Value("${jdbc.username}")
	private String username;
	
	@Value("${jdbc.password}")
	private String password;
	/**
	 * Configure data sources
	 * @return
	 */
	@Bean
	public DataSource dataSource(){
		DruidDataSource druidDataSource = new DruidDataSource(); 
		druidDataSource.setDriverClassName(driver);
		druidDataSource.setUrl(url);
		druidDataSource.setUsername(username);
		druidDataSource.setPassword(password);
		return druidDataSource;
	}

	/**
	 * Transaction manager
	 * @param dataSource
	 * @return
	 */
	@Bean
	public DataSourceTransactionManager txManager(DataSource dataSource){
		return new DataSourceTransactionManager(dataSource);
	}

}

4.3.3 Spring MVC configuration class

package com.czxy.ssm.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurationSupport;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
import org.springframework.web.servlet.view.InternalResourceViewResolver;

@Configuration
@ComponentScan(basePackages="com.czxy.ssm.controller")
//public class MvcConfiguration extends WebMvcConfigurationSupport {
public class MvcConfiguration implements WebMvcConfigurer {
	/**
	 * view resolver 
	 * @return
	 */
	@Bean
	public InternalResourceViewResolver internalResourceViewResolver(){
		InternalResourceViewResolver viewResolver = new InternalResourceViewResolver();
		//Prefix jsp folder
		viewResolver.setPrefix("/WEB-INF/pages/");
		//Suffix jsp extension
		viewResolver.setSuffix(".jsp");
		return viewResolver;
	}


}

4.3.4 startup configuration class

package com.czxy.ssm.config;

import org.springframework.web.WebApplicationInitializer;
import org.springframework.web.context.support.AnnotationConfigWebApplicationContext;
import org.springframework.web.filter.CharacterEncodingFilter;
import org.springframework.web.servlet.DispatcherServlet;

import javax.servlet.FilterRegistration;
import javax.servlet.ServletContext;
import javax.servlet.ServletException;
import javax.servlet.ServletRegistration;

public class WebInitializer implements WebApplicationInitializer {

	@Override
	public void onStartup(ServletContext servletContext) throws ServletException {
		//1 configure spring Factory
		AnnotationConfigWebApplicationContext application = new AnnotationConfigWebApplicationContext();
		// Register all configuration classes
		application.register(MyBatisConfiguration.class);
		application.register(SpringConfiguration.class);
		application.register(MvcConfiguration.class);
		
		//2 post Chinese garbled code
		FilterRegistration.Dynamic encodingFilter = servletContext.addFilter("encoding", new CharacterEncodingFilter("UTF-8"));
		encodingFilter.addMappingForUrlPatterns(null, true, "/*");
		
		//3 core controller
		ServletRegistration.Dynamic mvcServlet = servletContext.addServlet("springmvc", new DispatcherServlet(application));
		//mvcServlet.addMapping("*.action");
		mvcServlet.addMapping("/");
		mvcServlet.setLoadOnStartup(2);	//When tomcat starts, the initialization method of servlet is executed
		
	}

}

4.4 query all

4.4.1 requirements

Complete all functions of query

4.4.2 steps

  • Step 1: write a JavaBean (User)
    • Provide field and table class correspondence
    • Add MyBatis related annotation @ Id, etc
  • Step 2: write Mapper (UserMapper)
    • Integrate common Mapper
  • Step 3: write a service
    • Need to manage transactions
  • Step 4: write controller
    • Processing request path
    • Select view page list
  • Step 5: the list.jsp page displays data (non key)

4.4.3 realization

  • Step 1: write a JavaBean (User)

    • Provide field and table class correspondence
    • Add MyBatis related annotation @ Id, etc
    @Entity(name="user")
public class User {
    @Id
    private String uid;
	@Column(name="username")
    private String userName;
    private String password;
    private String name;
    private String email;
    private String telephone;
    private Date birthday;
    private String sex;
    private Integer state;
    private String code;
    // Omit getter s and setter s
}

  • Step 2: write Mapper (UserMapper)

    • Integrate common Mapper
    package com.czxy.ssm.mapper;

import com.czxy.ssm.domain.User;
import tk.mybatis.mapper.common.Mapper;

/**
 * @author Maynor
 * Maynor Big data Road
 */
public interface UserMapper extends Mapper<User> {
}

  • Step 3: write a service

    • Need to manage transactions
    package com.czxy.ssm.service;

import com.czxy.ssm.domain.User;

import java.util.List;

/**
 * @author Maynor
 * Maynor Big data Road
 */
public interface UserService {
    /**
     * Query all
     * @return
     */
    public List<User> selectAll();
}


    package com.czxy.ssm.service.impl;

import com.czxy.ssm.domain.User;
import com.czxy.ssm.mapper.UserMapper;
import com.czxy.ssm.service.UserService;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.util.List;

/**
 * @author Maynor
 * Maynor Big data Road
 */
@Service
@Transactional
public class UserServiceImpl implements UserService {

    @Resource
    private UserMapper userMapper;

    @Override
    public List<User> selectAll() {
        return userMapper.selectAll();
    }
}

  • Step 4: write controller

    • Processing request path
    • Select view page list
    package com.czxy.ssm.controller;

import com.czxy.ssm.domain.User;
import com.czxy.ssm.service.UserService;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;

import javax.annotation.Resource;
import java.util.List;

/**
 * @author Maynor
 * Maynor Big data Road
 */
@Controller
@RequestMapping("/user")
public class UserController {

    @Resource
    private UserService userService;

    @RequestMapping("/selectAll")
    public String selectAll(Model model) {

        // Query all
        List<User> list = userService.selectAll();

        // Store the query results in the request -- > model
        model.addAttribute("list", list);

        // Set view name
        return "list";
    }

}

  • Step 5: the list.jsp page displays data (non key)

    <%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<html>
<head>
    <title>Title</title>
</head>
<body>

    <table border="1" width="800">
        <tr>
            <td>number</td>
            <td>Login name</td>
            <td>nickname</td>
            <td>email</td>
            <td>Telephone</td>
            <td>operation</td>
        </tr>
        <c:forEach items="${list}" var="user">
            <tr>
                <td>${user.uid}</td>
                <td>${user.userName}</td>
                <td>${user.name}</td>
                <td>${user.email}</td>
                <td>${user.telephone}</td>
                <td>
                    modify
                    delete
                </td>
            </tr>
        </c:forEach>
    </table>
</body>
</html>

4.5 add

4.5.1 requirements

Complete user addition

4.5.2 steps

  • Step 1: click the Add button to display the add form

  • Step 2: write a controller to handle adding functions

    • After adding successfully, jump to the list page
    • After the addition fails, forward the addition page and prompt the error message

  • Step 3: write a service to complete the addition

4.5.3 realization

  • Step 1: click the Add button to display the add form

    • 1.1 in the list.jsp page, write the Add button

      <a href="${pageContext.request.contextPath}/user/addUI.action">add to</a>

    • 1.2 programming UserController display jsp

          /**
     * Display page
     * @return
     */
    @RequestMapping("/addUI")
    public String addUI() {
        return "add";
    }

    • 1.3 writing forms

      <%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
    <%--  error message   --%>
    <font color="red"> ${msg}</font>

    <form action="${pageContext.request.contextPath}/user/add.action" method="post">
        user name:<input type="text" name="userName" /> <br/>
        password:<input type="password" name="password" /> <br/>
        Nickname?<input type="text" name="name" /> <br/>
        <input type="submit" value="Add user"/>
    </form>
</body>
</html>

  • Step 2: write a controller to handle adding functions

    • After adding successfully, jump to the list page
    • After the addition fails, forward the addition page and prompt the error message
    /**
     *
     * @param user
     * @param model
     * @return
     */
    @RequestMapping("/add")
    public String add(User user, Model model) {
        // Add user
        boolean result = userService.add(user);
        if(result) {
            // Added successfully
            return "redirect:/user/selectAll.action";
        } else {
            // Add failed
            model.addAttribute("msg", "Add failed");
            return "forward:/WEB-INF/pages/add.jsp";
        }

    }

  • Step 3: write the service and finish adding (interface + implementation class)

        /**
     * add to
     * @param user
     * @return
     */
    boolean add(User user);

          @Override
    public boolean add(User user) {
        // Auto generate id
        String uuidString = UUID.randomUUID().toString().replace("-","");
        user.setUid(uuidString);
        int insert = userMapper.insert(user);
        return insert == 1;
    }

Topics: Java Back-end RESTful mvc

Hot Topics

©2024 Programmer Think