SpringMVC+MyBatis - 12 spring mvc4返回的json日期为Long的解决方案

本文介绍SpringMVC中JSON日期格式化的多种方法,包括全局配置、局部注解处理和自定义序列化器等,确保JSON响应符合预期格式。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

摘自 http://tramp-zzy.iteye.com/blog/2090330   2014-07-10
方法一:全局处理
<mvc:annotation-driven>  
    <!-- 处理responseBody 里面日期类型 -->  
        <mvc:message-converters>  
            <bean  class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter">  
                <property name="objectMapper">  
                    <bean  class="com.fasterxml.jackson.databind.ObjectMapper">  
                        <property name="dateFormat">  
                            <bean  class="java.text.SimpleDateFormat">  
                                <constructor-arg type="java.lang.String" value="yyyy-MM-dd HH:mm:ss" />  
                            </bean>  
                        </property>  
                    </bean>  
                </property>  
            </bean>  
        </mvc:message-converters>  
    </mvc:annotation-driven>  
方法二:局部注解处理 
import java.io.IOException;  
import java.text.SimpleDateFormat;  
import java.util.Date;  
  
import com.fasterxml.jackson.core.JsonGenerator;  
import com.fasterxml.jackson.core.JsonProcessingException;  
import com.fasterxml.jackson.databind.JsonSerializer;  
import com.fasterxml.jackson.databind.SerializerProvider;  
  
/**   
 * ClassName:DateJsonSerializer <br/>  
 * Function: 日期类型格式化,格式化为:yyyy-MM-dd HH:mm:ss 格式. 用法如下:<br/>  
 * Reason:   @JsonSerialize(using=DateJsonSerializer.class) 
 *           @Column(name="BIRTHDAY") 
 *           public Date getBirthday() { 
 *              return birthday; 
 *           } 
 *          . <br/>  
 * Date:     2014年7月10日 下午1:26:08 <br/>  
 * 
@author    zhangzhaoyu  
 * 
@version    1.0 
 * 
@since     JDK 1.7  
 * 
@see         
 
*/  
public  class DateJsonSerializer  extends JsonSerializer<Date> {  
  
    @Override  
     public  void serialize(Date value, JsonGenerator jgen,  
            SerializerProvider provider)  throws IOException,  
            JsonProcessingException {  
         SimpleDateFormat formatter =  new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");  
         String formattedDate = formatter.format(value);  
         jgen.writeString(formattedDate);  
    }  
  
}  
方法三:jackson 注解处理
@JsonIgnoreProperties  
         此注解是类注解,作用是json序列化时将java bean中的一些属性忽略掉,序列化和反序列化都受影响。  
  
@JsonIgnore  
         此注解用于属性或者方法上(最好是属性上),作用和上面的@JsonIgnoreProperties一样。  
  
@JsonFormat  
        此注解用于属性或者方法上(最好是属性上),可以方便的把Date类型直接转化为我们想要的模式,比如@JsonFormat(pattern = "yyyy-MM-dd HH-mm-ss")  
  
@JsonSerialize  
  
  //  反序列化一个固定格式的Date    
    @JsonDeserialize(using = CustomDateDeserialize. class)    
     public  void setBirthday(Date birthday) {    
         this.birthday = birthday;    
    }   
  
  //  序列化指定格式的double格式    
    @JsonSerialize(using = CustomDoubleSerialize. class)    
     public  double getSalary() {    
         return salary;    
    }    
  
public  class CustomDateDeserialize  extends JsonDeserializer<Date> {    
    
     private SimpleDateFormat sdf =  new SimpleDateFormat("yyyy-MM-dd");    
    
    @Override    
     public Date deserialize(JsonParser jp, DeserializationContext ctxt)    
             throws IOException, JsonProcessingException {    
    
        Date date =  null;    
         try {    
            date = sdf.parse(jp.getText());    
        }  catch (ParseException e) {    
            e.printStackTrace();    
        }    
         return date;    
    }    
}   


spring mvc4使用及json 日期转换解决方案

摘自: http://blog.youkuaiyun.com/zhanngle/article/details/24123659    2014-04-19
又到搭新开发环境的时候,总是不免去网上搜下目前最新的框架。spring是web开发必用的框架,于是乎下载了目前最新的spring4.0.3,同时越来越不想用struts2,想试试spring mvc,也将spring-webmvc4.0.3下了下来,投入两天时间学习后,发现还是挺优雅的,特别是从3.0后,spring mvc使用注解方式配制,以及对rest风格的支持,真是完美致极。
下面将这两天研究到的问题做个总结,供参考。
1.request对象的获取
方式1:
在controller方法上加入request参数,spring会自动注入,如:
public String list(HttpServletRequest request,HttpServletResponse response)
方式2: 在controller类中加入@Resource private HttpServletRequest request 属性,spring会自动注入,这样不知道会不会出现线程问题,因为一个controller实例会为多个请求服务,暂未测试。
方式3: 在controller方法中直接写代码获取 
HttpServletRequest request = ((ServletRequestAttributes)RequestContextHolder.getRequestAttributes()).getRequest();
方式4: 在controller中加入以下方法,此方法会在执行此controller的处理方法之前执行
@ModelAttribute  
private  void initServlet(HttpServletRequest request,HttpServletResponse response) {  
     // String p=request.getParameter("p");  
    
// this.req=request; // 实例变量,有线程安全问题,可以使用ThreadLocal模式保存  
}  

2.response对象的获取

可以参照以上request的获取方式1和方式4,方式2和方式3对response对象无效!
3.表单提交之数据填充

直接在方法上加入实体对象参数,spring会自动填充对象中的属性,对象属性名要与<input>的name一致才会填充.
如:public boolean doAdd(Demo demo)

4.表单提交之数据转换-Date类型

在实体类的属性或get方法上加入 @DateTimeFormat(pattern="yyyy-MM-dd HH:mm:ss"),那么表单中的日期字符串就会正确的转换为Date类型了。
还有@NumberFormat注解,暂时没用,就不介绍了,一看就知道是对数字转换用的。

5.json数据返回
在方法上加入@ResponseBody,同时方法返回值为实体对象,spring会自动将对象转换为json格式,并返回到客户端。如下所示:
@RequestMapping("/json1")  
@ResponseBody  
public Demo json1() {  
    Demo demo= new Demo();  
    demo.setBirthday( new Date());  
    demo.setCreateTime( new Date());  
    demo.setHeight(170);  
    demo.setName("tomcat");   
    demo.setRemark("json测试");   
    demo.setStatus(( short)1);   
     return demo;  
}  
注意:spring配置文件要加上:<mvc:annotation-driven/>,同时还要引入jackson-core.jar,jackson-databind.jar,jackson-annotations.jar(2.x的包)才会自动转换json
这种方式是spring提供的。我们还可以自定义输出json,以上第二条不是说了获取response对象吗,拿到response对象后,任由开发人员宰割,想怎么返回就怎么返回。
方法不要有返回值 ,如下:
@RequestMapping("/json2")  
public  void json2() {  
    Demo demo= new Demo();  
    demo.setBirthday( new Date());  
    demo.setCreateTime( new Date());  
    demo.setHeight(170);  
    demo.setName("tomcat");  
    demo.setRemark("json测试");  
    demo.setStatus(( short)1);  
     String json=JsonUtil.toJson(obj);//;json处理工具类  
    HttpServletResponse response = //获取response对象  
    response.getWriter().print(json);  

}  
OK,一切很完美。接着恶心的问题迎面而来, date类型转换为json字符串时,返回的是long time值 ,如果你想返回“yyyy-MM-dd HH:mm:ss”格式的字符串,又要自定义了。我很奇怪,不是有@DateTimeFormat注解吗,为什么不利用它。难道@DateTimeFormat只在表单提交时,将字符串转换为date类型,而date类型转换为json字符串时,就不用了。带着疑惑查源码, 原来spring使用jackson转换json字符,而@DateTimeFormat是spring-context包中的类,jackson如何转换,spring不方便作过多干涉 ,于是只能遵守jackson的转换规则,自定义日期转换器。
先写一个日期转换器,如下:
public  class JsonDateSerializer  extends JsonSerializer<Date> {  
    private SimpleDateFormat dateFormat= new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");  
   @Override  
    public  void serialize(Date date, JsonGenerator gen, SerializerProvider provider)   throws IOException, JsonProcessingException {  
       String value = dateFormat.format(date);  
       gen.writeString(value);  
   }  
}  
在实体类的get方法上配置使用转换器,如下:
@DateTimeFormat(pattern="yyyy-MM-dd HH:mm:ss")  
@JsonSerialize(using=JsonDateSerializer. class)  
public Date getCreateTime() {  
     return  this.createTime;  
}  
OK,到此搞定。
你真的满意了吗,这么不优雅的解决方案,假设birthday属性是这样的,只有年月日,无时分秒
@DateTimeFormat(pattern="yyyy-MM-dd")  
public Date getBirthday() {  
     return  this.birthday;  
}  
这意味着,又要为它定制一个JsonDate2Serializer的转换器,然后配置上,像这样

@DateTimeFormat(pattern="yyyy-MM-dd")  
@JsonSerialize(using=JsonDate2Serializer. class)  
public Date getBirthday() {  
     return  this.birthday;  
}  
假设还有其它格式的Date字段,还得要为它定制另一个转换器。my god,请饶恕我的罪过,不要让我那么难受
经过分析源码,找到一个不错的方案,此方案将不再使用@JsonSerialize,而只利用@DateTimeFormat配置日期格式,jackson就可以正确转换,但@DateTimeFormat只能配置在get方法上,这也没什么关系。
先引入以下类,此类对jackson的ObjectMapper类做了注解扫描拦截,使它也能对加了@DateTimeFormat的get方法应用日期格式化规则
package com.xxx.utils;  
  
import java.io.IOException;  
import java.lang.reflect.AnnotatedElement;  
import java.text.SimpleDateFormat;  
import java.util.Date;  
import org.springframework.format.annotation.DateTimeFormat;  
import org.springframework.stereotype.Component;  
import com.fasterxml.jackson.core.JsonGenerator;  
import com.fasterxml.jackson.core.JsonProcessingException;  
import com.fasterxml.jackson.databind.JsonSerializer;  
import com.fasterxml.jackson.databind.ObjectMapper;  
import com.fasterxml.jackson.databind.SerializerProvider;  
import com.fasterxml.jackson.databind.introspect.Annotated;  
import com.fasterxml.jackson.databind.introspect.AnnotatedMethod;  
import com.fasterxml.jackson.databind.introspect.JacksonAnnotationIntrospector;  
  
/**  
 * json处理工具类 
 * 
@author  zhangle 
 
*/  
@Component  
public  class JsonUtil {  
         private  static  final String DEFAULT_DATE_FORMAT="yyyy-MM-dd HH:mm:ss";  
         private  static  final ObjectMapper mapper;  
          
         public ObjectMapper getMapper() {  
                 return mapper;  
        }  
  
         static {  
                SimpleDateFormat dateFormat =  new SimpleDateFormat(DEFAULT_DATE_FORMAT);  
                  
                mapper =  new ObjectMapper();  
                mapper.setDateFormat(dateFormat);  
                mapper.setAnnotationIntrospector( new JacksonAnnotationIntrospector() {  
                        @Override  
                         public Object findSerializer(Annotated a) {  
                                 if(a  instanceof AnnotatedMethod) {  
                                        AnnotatedElement m=a.getAnnotated();  
                                        DateTimeFormat an=m.getAnnotation(DateTimeFormat. class);  
                                         if(an!= null) {  
                                                 if(!DEFAULT_DATE_FORMAT.equals(an.pattern())) {  
                                                         return  new JsonDateSerializer(an.pattern());  
                                                }  
                                        }  
                                }  
                                 return  super.findSerializer(a);  
                        }  
                });  
        }  
          
         public  static String toJson(Object obj) {  
                 try {  
                         return mapper.writeValueAsString(obj);  
                }  catch (Exception e) {  
                         throw  new RuntimeException("转换json字符失败!");  
                }  
        }  
          
         public <T> T toObject(String json,Class<T> clazz) {  
                 try {  
                         return mapper.readValue(json, clazz);  
                }  catch (IOException e) {  
                         throw  new RuntimeException("将json字符转换为对象时失败!");  
                }  
        }  
          
         public  static  class JsonDateSerializer  extends JsonSerializer<Date>{  
             private SimpleDateFormat dateFormat;  
             public JsonDateSerializer(String format) {  
                 dateFormat =  new SimpleDateFormat(format);  
                }  
              
            @Override  
             public  void serialize(Date date, JsonGenerator gen, SerializerProvider provider)  
                     throws IOException, JsonProcessingException {  
                String value = dateFormat.format(date);  
                gen.writeString(value);  
            }  
        }  
}  
再将<mvc:annotation-driven/>改为以下配置,配置一个新的json转换器,将它的ObjectMapper对象设置为JsonUtil中的objectMapper对象,此转换器比spring内置的json转换器优先级更高,所以与json有关的转换,spring会优先使用它。
<mvc:annotation-driven>  
    <mvc:message-converters>  
        <bean  class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter">  
            <property name="objectMapper" value="#{jsonUtil.mapper}"/>  
            <property name="supportedMediaTypes">  
                <list>  
                    <value>text/json;charset=UTF-8</value>  
                </list>  
            </property>    
        </bean>  
    </mvc:message-converters>  
</mvc:annotation-driven>  
接下来就可以这样配置实体类,jackson也能正确转换Date类型
@DateTimeFormat(pattern="yyyy-MM-dd HH:mm:ss")  
public Date getCreateTime() {  
     return  this.createTime;  
}  
@DateTimeFormat(pattern="yyyy-MM-dd")  
public Date getBirthday() {  
     return  this.birthday;  
}  

完毕,一切都完美了。


以下为2014/4/21 补充

写了那么多,发现白忙活了一场,原来jackson也有一个@JsonFormat注解,将它配置到Date类型的get方法上后,jackson就会按照配置的格式转换日期类型,而不自定义转换器类,欲哭无泪啊。辛苦了那么多,其实别人早已提供,只是没有发现而已。

不说了,直接上方案吧。

1.spring配置照样是这样:

  1. <mvc:annotation-driven>  
2.JsonUtil可以不用了,但如果要自己从response对象输出json,那么还是可以用,但改成了这样
package com.xxx.utils;  
  
import java.io.IOException;  
import java.text.SimpleDateFormat;  
import org.springframework.stereotype.Component;  
import com.fasterxml.jackson.databind.ObjectMapper;  
  
/**  
 * json处理工具类 
 * 
@author  zhangle 
 
*/  
@Component  
public  class JsonUtil {  
  
     private  static  final String DEFAULT_DATE_FORMAT="yyyy-MM-dd HH:mm:ss";  
     private  static  final ObjectMapper mapper;  
  
     static {  
        SimpleDateFormat dateFormat =  new SimpleDateFormat(DEFAULT_DATE_FORMAT);  
        mapper =  new ObjectMapper();  
        mapper.setDateFormat(dateFormat);  
    }  
      
     public  static String toJson(Object obj) {  
         try {  
             return mapper.writeValueAsString(obj);  
        }  catch (Exception e) {  
             throw  new RuntimeException("转换json字符失败!");  
        }  
    }  
      
     public <t> T toObject(String json,Class<t> clazz) {  
         try {  
             return mapper.readValue(json, clazz);  
        }  catch (IOException e) {  
             throw  new RuntimeException("将json字符转换为对象时失败!");  
        }  
    }  
}

3.实体类的get方法就需要多一个@JsonFormat的注解配置
@DateTimeFormat(pattern="yyyy-MM-dd HH:mm:ss")  
@JsonFormat(pattern="yyyy-MM-dd HH:mm:ss",timezone = "GMT+8")  
public Date getCreateTime() {  
return  this.createTime;  
}  
@DateTimeFormat(pattern="yyyy-MM-dd")  
@JsonFormat(pattern="yyyy-MM-dd",timezone = "GMT+8")  
public Date getBirthday() {  
     return  this.birthday;  

<think>我们正在开发一个基于SSM框架的学生管理系统,需要实现注册、登录、增删查改功能。重点技术点包括:1.Spring依赖注入2.Spring事务管理3.MyBatis数据存取与动态SQL4.SpringMVC服务编写5.JSON交互6.Restful服务开发我们将分步骤构建项目,并给出关键代码示例。###1.项目结构典型的SSM项目结构如下:```src├──main│├──java││└──com││└──example││├──controller#SpringMVC控制器││├──service#服务层接口││├──service/impl#服务层实现││├──dao#MyBatisMapper接口││├──entity#实体类││└──config#配置类│├──resources││├──mapper#MyBatis映射文件││├──applicationContext.xml#Spring配置││├──spring-mvc.xml#SpringMVC配置││├──mybatis-config.xml#MyBatis配置││└──jdbc.properties#数据库连接配置│└──webapp│└──WEB-INF│└──web.xml#Web配置```###2.Spring依赖注入依赖注入(DI)是Spring的核心,通过配置将对象依赖关系交给Spring容器管理。**示例:Service注入Dao**```java//实体类publicclassStudent{privateLongid;privateStringname;privateIntegerage;//省略getter/setter}//Dao接口publicinterfaceStudentDao{StudentfindById(Longid);}//Mapper文件StudentMapper.xml<mappernamespace="com.example.dao.StudentDao"><selectid="findById"resultType="com.example.entity.Student">SELECT*FROMstudentWHEREid=#{id}</select></mapper>//Service接口publicinterfaceStudentService{StudentgetStudentById(Longid);}//Service实现类,使用@Autowired注入Dao@ServicepublicclassStudentServiceImplimplementsStudentService{@AutowiredprivateStudentDaostudentDao;@OverridepublicStudentgetStudentById(Longid){returnstudentDao.findById(id);}}```###3.Spring事务管理在Service层使用声明式事务管理,确保数据库操作的原子性。**配置事务管理器(在Spring配置文件中)**```xml<beanid="transactionManager"class="org.springframework.jdbc.datasource.DataSourceTransactionManager"><propertyname="dataSource"ref="dataSource"/></bean><tx:annotation-driventransaction-manager="transactionManager"/>```**在Service方法上使用事务注解**```java@ServicepublicclassStudentServiceImplimplementsStudentService{//...省略注入@Transactional@OverridepublicvoidsaveStudent(Studentstudent){//插入学生记录studentDao.insert(student);//这里可以有多个数据库操作,它们在一个事务中}}```###4.MyBatis数据存取与动态SQLMyBatis通过XML或注解配置SQL,动态SQL用于条件查询。**动态SQL示例(根据条件查询学生)**```xml<selectid="findStudents"resultType="Student">SELECT*FROMstudent<where><iftest="name!=null">ANDnameLIKECONCAT('%',#{name},'%')</if><iftest="age!=null">ANDage=#{age}</if></where></select>```###5.SpringMVC服务编写SpringMVC负责接收HTTP请求并调用Service层处理。**编写Controller**```java@RestController@RequestMapping("/students")publicclassStudentController{@AutowiredprivateStudentServicestudentService;//根据ID查询学生@GetMapping("/{id}")publicStudentgetStudentById(@PathVariableLongid){returnstudentService.getStudentById(id);}//添加学生@PostMappingpublicResponseEntity<String>addStudent(@RequestBodyStudentstudent){studentService.saveStudent(student);returnResponseEntity.ok("添加成功");}}```###6.JSON交互与Restful服务开发使用`@RestController`和`@RequestBody`、`@ResponseBody`实现JSON交互,上述Controller已经体现。**Restful风格API设计:**-GET/students:获取所有学生-GET/students/{id}:获取单个学生-POST/students:创建学生-PUT/students/{id}:更新学生-DELETE/students/{id}:删除学生###完整示例:注册和登录功能**注册功能**1.用户注册需要插入用户表(可能需要事务,比如同时初始化用户角色)2.密码需要加密存储(如使用BCryptPasswordEncoder)**登录功能**1.验证用户名和密码2.生成Token(如JWT)并返回**代码示例:**```java//用户注册@PostMapping("/register")publicResponseEntity<?>registerUser(@RequestBodyUseruser){//密码加密user.setPassword(passwordEncoder.encode(user.getPassword()));userService.saveUser(user);//事务方法returnResponseEntity.ok("注册成功");}//用户登录@PostMapping("/login")publicResponseEntity<?>login(@RequestBodyLoginRequestloginRequest){Useruser=userService.findByUsername(loginRequest.getUsername());if(user!=null&&passwordEncoder.matches(loginRequest.getPassword(),user.getPassword())){//生成JWTStringtoken=JwtUtil.generateToken(user.getUsername());returnResponseEntity.ok(newJwtResponse(token));}returnResponseEntity.status(401).body("用户名或密码错误");}```###总结通过以上步骤,我们构建了一个包含基本CRUD和注册登录功能的学生管理系统。重点包括:-使用Spring依赖注入管理Bean-使用Spring事务确保数据一致性-MyBatis动态SQL实现灵活查询-SpringMVC编写RestfulAPI-JSON交互处理请求和响应§§相关问题§§1.如何在SSM框架中整合SpringSecurity实现更安全的登录验证?2.MyBatis如何实现分页查询?有哪些分页插件?3.Spring事务管理中,事务传播行为和隔离级别如何配置?4.SpringMVC中,如何处理全局异常?5.如何优化MyBatis的数据库查询性能?</think>### 基于SSM框架的学生管理系统开发指南 #### 一、项目基础配置 1. **Maven依赖配置** (pom.xml) ```xml <dependencies> <!-- Spring核心 --> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-context</artifactId> <version>5.3.18</version> </dependency> <!-- SpringMVC --> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-webmvc</artifactId> <version>5.3.18</version> </dependency> <!-- MyBatis整合 --> <dependency> <groupId>org.mybatis</groupId> <artifactId>mybatis-spring</artifactId> <version>2.0.7</version> </dependency> <!-- JSON处理 --> <dependency> <groupId>com.fasterxml.jackson.core</groupId> <artifactId>jackson-databind</artifactId> <version>2.13.3</version> </dependency> </dependencies> ``` #### 二、核心技术实现 ##### 1. Spring依赖注入 **实体类定义**: ```java public class Student { private Long id; private String name; private String studentId; // 学号 // getters/setters } ``` **Service层依赖注入**: ```java @Service public class StudentServiceImpl implements StudentService { // 通过@Autowired自动注入DAO @Autowired private StudentDao studentDao; @Override public Student getStudentById(Long id) { return studentDao.findById(id); } } ``` ##### 2. Spring事务管理 ```java @Service public class StudentServiceImpl implements StudentService { @Transactional( propagation = Propagation.REQUIRED, rollbackFor = Exception.class ) @Override public void updateStudent(Student student) { studentDao.update(student); // 此处可添加其他需要事务管理的操作 } } ``` ##### 3. MyBatis数据操作 **Mapper接口**: ```java public interface StudentDao { @Select("SELECT * FROM students WHERE id = #{id}") Student findById(Long id); @Insert("INSERT INTO students(name, student_id) VALUES(#{name}, #{studentId})") void insert(Student student); } ``` **动态SQL示例**: ```xml <!-- StudentMapper.xml --> <select id="findByCondition" resultType="Student"> SELECT * FROM students <where> <if test="name != null"> AND name LIKE CONCAT('%', #{name}, '%') </if> <if test="studentId != null"> AND student_id = #{studentId} </if> </where> </select> ``` ##### 4. Spring MVC服务编写 **RESTful控制器**: ```java @RestController @RequestMapping("/api/students") public class StudentController { @Autowired private StudentService studentService; // 注册接口 @PostMapping("/register") public ResponseEntity<String> register(@RequestBody Student student) { studentService.register(student); return ResponseEntity.ok("注册成功"); } // 登录接口 @PostMapping("/login") public ResponseEntity<Student> login(@RequestParam String studentId, @RequestParam String password) { Student student = studentService.login(studentId, password); return ResponseEntity.ok(student); } } ``` ##### 5. JSON交互配置 **SpringMVC配置类**: ```java @Configuration @EnableWebMvc public class WebConfig implements WebMvcConfigurer { // 配置JSON消息转换器 @Override public void configureMessageConverters(List<HttpMessageConverter<?>> converters) { converters.add(new MappingJackson2HttpMessageConverter()); } } ``` ##### 6. Restful服务开发 **CRUD接口示例**: ```java @RestController @RequestMapping("/api/students") public class StudentController { // 获取所有学生 @GetMapping public List<Student> getAllStudents() { return studentService.getAllStudents(); } // 根据ID查询学生 @GetMapping("/{id}") public Student getStudent(@PathVariable Long id) { return studentService.getStudentById(id); } // 更新学生信息 @PutMapping("/{id}") public ResponseEntity<String> updateStudent(@PathVariable Long id, @RequestBody Student student) { student.setId(id); studentService.updateStudent(student); return ResponseEntity.ok("更新成功"); } // 删除学生 @DeleteMapping("/{id}") public ResponseEntity<String> deleteStudent(@PathVariable Long id) { studentService.deleteStudent(id); return ResponseEntity.ok("删除成功"); } } ``` #### 三、安全增强(登录验证) ```java @Service public class AuthServiceImpl implements AuthService { @Autowired private StudentDao studentDao; @Override public boolean authenticate(String studentId, String password) { Student student = studentDao.findByStudentId(studentId); return student != null && student.getPassword().equals(password); } } ``` #### 四、项目结构建议 ``` src ├── main │ ├── java │ │ └── com │ │ └── example │ │ ├── controller # 控制器层 │ │ ├── service # 服务接口 │ │ ├── service/impl # 服务实现 │ │ ├── dao # MyBatis Mapper │ │ ├── entity # 实体类 │ │ └── config # 配置类 │ ├── resources │ │ ├── mapper # MyBatis XML文件 │ │ ├── applicationContext.xml # Spring配置 │ │ └── spring-mvc.xml # SpringMVC配置 ``` #### 五、关键注意事项 1. **事务边界**:事务管理应放在Service层 2. **RESTful规范**: - GET:查询资源 - POST:创建资源 - PUT:更新资源 - DELETE:删除资源 3. **JSON处理**:使用`@RequestBody`接收JSON参数,`@ResponseBody`返回JSON数据 4. **动态SQL**:复杂查询使用MyBatis的`<where>`、`<if>`标签 > 提示:在实际开发中,建议添加参数校验(如Hibernate Validator)、统一异常处理、日志记录和安全防护措施[^4]。
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值