SpringBoot经常使用注解

时间  2020-08-22
标签 springboot 经常 使用 注解 栏目 Spring 繁體版
原文   原文链接

1、注解(annotations)列表
@SpringBootApplication：包含了@ComponentScan、@Configuration和@EnableAutoConfiguration注解。其中:@ComponentScan让SpringBoot扫描到Configuration类并把它加入到程序上下文。
@Configuration 等同于spring的XML配置文件；使用Java代码能够检查类型安全。
@EnableAutoConfiguration 自动配置。
@ComponentScan 组件扫描，可自动发现和装配一些Bean。
@Component可配合CommandLineRunner使用，在程序启动后执行一些基础任务。
@RestController注解是@Controller和@ResponseBody的合集,表示这是个控制器bean,而且是将函数的返回值直接填入HTTP响应体中。
@Autowired自动注入。
@PathVariable获取参数。
@JsonBackReference解决嵌套外链问题。
@RepositoryRestResourcepublic配合spring-boot-starter-data-rest使用。html

2、注解(annotations)详解
@SpringBootApplication：申明让spring boot自动给程序进行必要的配置，这个配置等同于：@Configuration ，@EnableAutoConfiguration 和 @ComponentScan 三个配置。web

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication//@Configuration,@EnableAutoConfiguration,@ComponentScan
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

@RequestMapping：提供路由信息，负责URL到Controller中的具体函数的映射。
@Controller：用于定义控制器类，在spring 项目中由控制器负责将用户发来的URL请求转发到对应的服务接口（service层），通常这个注解在类中，一般方法须要配合注解@RequestMapping。
示例代码：spring

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
/**
 * 计划在这个controller中处理全部页面请求
 * @author ldjx
 */
@Controller
@RequestMapping("/")
public class PageController {
      //返回项目的首页页面
    @RequestMapping("doIndexUI")
    public String doIndexUI() {
        return "index";
    }
}

@ResponseBody：表示该方法的返回结果直接写入HTTP response body中，通常在异步获取数据时使用。在使用@RequestMapping后，返回值一般解析为跳转路径，加上@responsebody后返回结果不会被解析为跳转路径，而是直接写入HTTP response body中。好比异步获取json数据，加上@responsebody后，会直接返回json数据。该注解通常会配合@RequestMapping一块儿使用。示例代码：sql

@RequestMapping(“/test”)
@ResponseBody
public String test(){
    return”ok”;
}

或者返回自定义的类型,如使用JsonResult类对数据结果进行封装:数据库

@RequestMapping("/testDelete")
@ResponseBody
public JsonResult doDeleteObject(Integer id){
    //to delete...
    return new JsonResult("delete ok");
}

@RestController：用于标注控制层组件(如struts中的action)，@ResponseBody和@Controller的合集。
示例代码：编程

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

import com.cy.pj.common.pojo.JsonResult;
import com.cy.pj.sys.service.SysLogService;
/**
 * 尽可能将返回页面的请求处理与数据处理的controller分开
 * 只处理页面返回请求的使用@controller便可,将@RestController使用在返回数据处理的controller上
 * 避免了每一个方法上都加@ResponseBody的麻烦
 * @author ldjx
 */
@RestController //至关于@ResponseBody + @Controller
@RequestMapping("/test/")
public class SysLogController {

     @Autowired
     private TestService testService;
     
     @RequestMapping("doDeleteObject")
     public JsonResult doDeleteObjects(Integer id) {
         //调用业务方法执行删除操做...( testService.doDelete(id) )
         return new JsonResult("delete ok");
     }
     @RequestMapping("doFindObjects")
     public JsonResult doFindPageObjects(){
           return new JsonResult(testService.findObjects());//业务层返回的数据封装在JsonResult对象中
     }

@EnableAutoConfiguration：Spring Boot自动配置（auto-configuration）：尝试根据你添加的jar依赖自动配置你的Spring应用。例如，若是你的classpath下存在HSQLDB，而且你没有手动配置任何数据库链接beans，那么咱们将自动配置一个内存型（in-memory）数据库”。你能够将@EnableAutoConfiguration或者@SpringBootApplication注解添加到一个@Configuration类上来选择自动配置。若是发现应用了你不想要的特定自动配置类，你可使用@EnableAutoConfiguration注解的排除属性来禁用它们。
@ComponentScan：表示将该类自动发现扫描组件。我的理解至关于，若是扫描到有@Component、@Controller、@Service等这些注解的类，并注册为Bean，能够自动收集全部的Spring组件，包括@Configuration类。咱们常用@ComponentScan注解搜索beans，并结合@Autowired注解导入。能够自动收集全部的Spring组件，包括@Configuration类。咱们常用@ComponentScan注解搜索beans，并结合@Autowired注解导入。若是没有配置的话，Spring Boot会扫描启动类所在包下以及子包下的使用了@Service,@Repository等注解的类。
@Configuration：至关于传统的xml配置文件，若是有些第三方库须要用到xml文件，建议仍然经过@Configuration类做为项目的配置主类——可使用@ImportResource注解加载xml配置文件。
@Import：用来导入其余配置类。
@ImportResource：用来加载xml配置文件。
@Service：通常用于修饰service层的组件
@Repository：使用@Repository注解能够确保DAO或者repositories提供异常转译，这个注解修饰的DAO或者repositories类会被ComponetScan发现并配置，同时也不须要为它们提供XML配置项。
@Value：注入Spring boot application.properties配置的属性的值。示例代码：
@Value(value = "#{message}") private String message;
@Inject：等价于默认的@Autowired，只是没有required属性；
@Component：泛指组件，当组件很差归类的时候，咱们可使用这个注解进行标注。
@Bean：用@Bean标注方法等价于XML中配置的bean,放在方法的上面，而不是类，告诉Spring容器，你能够从下面这个方法中拿到一个Bean。
示例代码：json

public class ObjectTest{ }
//------------------------------------------------------------------------------
/*
 * @Bean 注解一般会应用在一些配置类(由@Configuration注解描述)中,用于描述
 * 具有返回值的方法,而后系统底层会经过反射调用其方法,获取对象基于做用域将对象
 * 进行存储或应用。
 * @Bean 应用场景：第三方资源的整合及配置。
 */
//@Bean("obj") //为返回值指定名字
@Bean //Spring容器中由@Bean描述的方法的返回值,对应的名字默认为方法名
public ObjectTest testObj() {
    return new ObjectTest();
}

@AutoWired：自动注入依赖的bean。byType方式。把配置好的Bean拿来用，完成属性、方法的组装，它能够对类成员变量、方法及构造函数进行标注，完成自动装配的工做。当加上（required=false）时，就算找不到bean也不报错。
@Qualifier：当有多个同一类型的Bean时，能够用@Qualifier(“name”)来指定。与@Autowired配合使用。@Qualifier限定描述符除了能根据名字进行注入，但能进行更细粒度的控制如何选择候选者，具体使用方式以下：缓存

public interface TestQua { }
//----------------------------------------------------------------------------------------------------------
public class QuaImpl01 implements TestQua{ }
//----------------------------------------------------------------------------------------------------------
public class QuaImpl02 implements TestQua{ }
//----------------------------------------------------------------------------------------------------------
@SpringBootTest//该注解用于SpringBoot项目中的测试类
public class CacheTest {
    //@Autowired注解描述属性时,系统底层会基于属性类型从spring容器查找对象,假若有多个类型都知足注入要求,则还会基于属性名进行查找,检测哪一个bean名字与属性相同,假若有相同的则直接取相同进行注入,没有则抛出异常
    @Autowired
    //@Qualifier注解配合@Autowired注解使用,用于指定将哪一个bean的名字对应的对象注入给描述的属性
    //@Qualifier("quaImpl01")
    @Qualifier("quaImpl02")
    private TestQua testQua;
    @Test
    void testCache() {
        System.out.println("testQua="+testQua);
    }
}

@Resource(name="name",type="type")：没有括号内内容的话，默认byName。与@Autowired干相似的事。
@Lazy:描述Spring管理的bean对象时,可让bean延迟构建和初始化.
延迟加载(懒加载,按需加载)应用场景:安全

大对象(例如一些池对象),稀少用(例如容器初始化时建立了对象也用不到).

@Scope:描述类时用于指定类实例的做用域,经常使用取值:架构

  • 1)singleton :默认为单例做用域-类的实例在一个JVM内存中其实例只有一份,此做用域一般还会配置@Lazy一块儿使用,通常可重用对象可设计为单例,对于这样的对象spring框架不只仅负责其建立,还会存储到bean池.
  • 2)prototype (多例做用域-此做用域对象什么时候须要什么时候建立,spring框架不负责销毁)通常不可重用对象,或者说只使用一次就再也不用此对象了,这样的对象就可设计为多例做用域.

@PostConstruct:此注解描述的方法为生命周期初始化方法.
@PreDestroy:此注解描述的方法为生命周期销毁方法,此方法会在对象销毁以前执行(若是是多例做用域,则不会触发此方法).
示例代码:

@Scope //spring容器中的bean没有使用@Scope注解描述时默认就是单例.
//@Scope("prototype")
@Lazy //默认value属性值为true,表示此对象要延迟构建及初始化.
//@Lazy(false)//这里假如要写false,跟没有写@Lazy注解是同样的,表示不支持对象延迟构建及初始化.
@Component //此注解描述bean表示这个bean对象会由spring建立,其名字默认为类名,首字母小写.
public class ObjectPool {//bean的名字objectPool
   public int size;
   public ObjectPool() {//使用lazy注解后,启动项目未触发构造方法,说明没有建立此对象(延迟加载生效)
       System.out.println("ObjectPool()");
   }
   /**
    * @PostConstruct 此注解描述的方法为生命周期初始化方法
    * 在这样的方法中通常会为建立好的对象再此进行一些初始化.
    */
   @PostConstruct
   public void init() {
       System.out.println("init()");
   }
   /**
    *@PreDestroy 此注解描述的方法为生命周期销毁方法,此方法会在对象销毁以前执行.
    * 在这样的方法中能够实现一些,资源销毁操做.
    */
   @PreDestroy
   public void destory() {//将对象从bean池中移除以前会执行此方法
      System.out.println("destory()");
   } 
}

3、JPA注解
@Entity：@Table(name="")：代表这是一个实体类。通常用于jpa这两个注解通常一块使用，可是若是表名和实体类名相同的话，@Table能够省略
@MappedSuperClass:用在肯定是父类的entity上。父类的属性子类能够继承。
@NoRepositoryBean:通常用做父类的repository，有这个注解，spring不会去实例化该repository。
@Column：若是字段名与列名相同，则能够省略。
@Id：表示该属性为主键。
@GeneratedValue(strategy = GenerationType.SEQUENCE,generator = "repair_seq")：表示主键生成策略是sequence（能够为Auto、IDENTITY、native等，Auto表示可在多个数据库间切换），指定sequence的名字是repair_seq。
@SequenceGeneretor(name = "repair_seq", sequenceName = "seq_repair", allocationSize = 1)：name为sequence的名称，以便使用，sequenceName为数据库的sequence名称，两个名称能够一致。
@Transient：表示该属性并不是一个到数据库表的字段的映射,ORM框架将忽略该属性。若是一个属性并不是数据库表的字段映射,就务必将其标示为@Transient,不然,ORM框架默认其注解为@Basic。@Basic(fetch=FetchType.LAZY)：标记能够指定实体属性的加载方式
@JsonIgnore：做用是json序列化时将Javabean中的一些属性忽略掉,序列化和反序列化都受影响。
@JoinColumn（name=”loginId”）:一对一：本表中指向另外一个表的外键。一对多：另外一个表指向本表的外键。
@OneToOne、@OneToMany、@ManyToOne：对应hibernate配置文件中的一对一，一对多，多对一。

4、springMVC相关注解
@RequestMapping：@RequestMapping("/path")表示该控制器处理全部"/path"的UR L请求。RequestMapping是一个用来处理请求地址映射的注解，可用于类或方法上。
用于类上，表示类中的全部响应请求的方法都是以该地址做为父路径。该注解有六个属性：

  • 1)params:指定request中必须包含某些参数值是，才让该方法处理。
  • 2)headers:指定request中必须包含某些指定的header值，才能让该方法处理请求。
  • 3)value:指定请求的实际地址，指定的地址能够是URI Template 模式
  • 4)method:指定请求的method类型， GET、POST、PUT、DELETE等
  • 5)consumes:指定处理请求的提交内容类型（Content-Type），如application/json,text/html;
  • 6)produces:指定返回的内容类型，仅当request请求头中的(Accept)类型中包含该指定类型才返回

@RequestParam：用在方法的参数前面。示例代码:

@RequestMapping("/test")
public String test(int userId) {//当不使用@RequestParam注解时,参数为非必传
    return "test";
}
//===========================================分隔线=============================================== 
@RequestMapping("/test")
public String test(@RequestParam Integer id) {//当使用@RequestParam注解时,参数为必传,且参数名为id
    return "test";
}
//===========================================分隔线===============================================
@RequestMapping("/list")
public String test(@RequestParam(value = "userId", defaultValue = "0", required = false) int userId) {
    /*
     * value值即请求参数的参数名；
     * required该参数是否必须。默认为true,因此默认必传；
     * defaultValue请求参数的默认值
     */
    return "list";
}

@PathVariable:路径变量。如

//rest风格(软件架构编码风格,这个风格中url的定义容许使用{}做为变量)的URL
//rest风格的url优点:
//1)能够更通用
//2)能够在异构平台下进行兼容
@RequestMapping("sys/{moduleUI}")
public String doModuleUI(@PathVariable String moduleUI) {
    return "sys/"+moduleUI;
}

参数与大括号里的名字同样要相同。
5、全局异常处理
@ControllerAdvice：包含@Component。能够被扫描到。统一处理异常。
@ExceptionHandler（Exception.class）：用在方法上面表示遇到这个异常就执行如下方法。
示例代码:

/**
 *     @ControllerAdvice 注解描述的类为spring web(MVC)控制层的一个全局异常处理对象,当控制层出现异常之后,首先会检
 *  测控制层类中是否有异常处理方法,假如没有或者不能处理当前异常,则会查找是否有@ControllerAdvice注解描述的类,
 *  而后检测全局异常处理类中是否有合适的异常处理方法.假如若有则直接调用方法处理异常.
 *
 *    为何要作全局异常处理?(提取共性)
 */
@ControllerAdvice
public class GlobalExceptionHandler {
    /**
     * @ExceptionHandler 注解描述的方法为一个异常处理方法,注解中定义的
     * 异常类型,为当前方法的能够处理的异常处理类型(固然也能够处理异常类型的子类类
     * 型).在异常处理方法中一般会定义一个异常参数,来接收异常对象.
     */
    @ExceptionHandler(RuntimeException.class)
    @ResponseBody
    public JsonResult doHandleRuntimeException(RuntimeException e) {
        return new JsonResult(e);//使用自定义JsonResult类对异常信息进行封装
    }
}

6、AOP注解(AspectJ框架)
@Aspect 注解用于标识或者描述AOP中的切面类型，基于切面类型构建的对象用于为目标对象进行功能扩展或控制目标对象的执行。
@Pointcut注解用于描述切面中的方法，并定义切面中的切入点（基于特定表达式的方式进行描述）:
image

bean表达式:
bean表达式通常应用于类级别，实现粗粒度的切入点定义，案例分析：

  • bean("userServiceImpl")指定一个userServiceImpl类中全部方法.
  • bean("*ServiceImpl")指定全部后缀为ServiceImpl的类中全部方法.

说明:bean表达式内部的对象是由spring容器管理的一个bean对象,表达式内部的名字应该是spring容器中某个bean的name.

within表达式:
within表达式应用于类级别，实现粗粒度的切入点表达式定义，案例分析：

  • within("aop.service.UserServiceImpl")指定当前包中这个类内部的全部方法.
  • within("aop.service.*") 指定当前目录下的全部类的全部方法.
  • within("aop.service..*") 指定当前目录以及子目录中类的全部方法.

within表达式应用场景分析：

  • 1)对全部业务bean都要进行功能加强，可是bean名字又没有规则。
  • 2)按业务模块(不一样包下的业务)对bean对象进行业务功能加强。

execution表达式:
execution表达式应用于方法级别，实现细粒度的切入点表达式定义，案例分析：
语法：execution(返回值类型 包名.类名.方法名(参数列表)).

  • execution(void aop.service.UserServiceImpl.addUser())匹配addUser方法。
  • execution(void aop.service.PersonServiceImpl.addUser(String)) 方法参数必须为String的addUser方法.
  • execution(* aop.service..*.*(..)) 万能配置.

@annotation表达式:
@annotaion表达式应用于方法级别，实现细粒度的切入点表达式定义，案例分析

  • @annotation(anno.RequiredTest) 匹配有此注解描述的方法。

其中:RequiredTest为咱们本身定义的注解,当咱们使用@RequiredTest注解修饰业务层方法时,系统底层会在执行此方法时进行咱们自定义的切面业务扩展操做(如自动将日志信息添加至数据库等操做)。

@Around注解用于描述切面中方法，这样的方法会被认为是一个环绕通知（核心业务方法执行以前和以后要执行的一个动做），@Aournd注解内部value属性的值为一个切入点表达式或者是切入点表达式的一个引用(这个引用为一个@PointCut注解描述的方法的方法名)。
ProceedingJoinPoint类为一个链接点类型，此类型的对象用于封装要执行的目标方法相关的一些信息。只能用于@Around注解描述的方法参数。

AOP编程的过程当中，基于AspectJ框架标准，spring中定义了五种类型的通知(通知描述的是一种扩展业务)，它们分别是：
@Before
@AfterReturning
@AfterThrowing
@After
@Around(优先级最高)
假如这些通知所有写到一个切面对象中，其执行顺序及过程以下:
image
测试代码:

@Component
@Aspect
public class TestAspect {
    @Pointcut("bean(*ServiceImpl)")//表示匹配后缀为ServiceImpl的全部对象
    public void doTime(){}
    
    @Before("doTime()")
    public void doBefore(JoinPoint jp){
        System.out.println("time doBefore()");
    }
    @After("doTime()")
    public void doAfter(){
        System.out.println("time doAfter()");
    }
    @AfterReturning("doTime()")
    public void doAfterReturning(){
        System.out.println("time doAfterReturning");
    }

    @AfterThrowing("doTime()")
    public void doAfterThrowing(){
        System.out.println("time doAfterThrowing");
    }
    
    @Around("doTime()")
    public Object doAround(ProceedingJoinPoint jp)throws Throwable{
        System.out.println("doAround.before");
        try{
            Object obj = jp.proceed();
            System.out.println("doAround.after");
            return obj;
        }catch(Throwable e){
            System.out.println(e.getMessage());
            throw e;
        }
    }
}

对于@AfterThrowing通知只有在出现异常时才会执行，因此当作一些异常监控时可在此方法中进行代码实现

@Order注解用于描述切面的优先级，数字越小优先级越高,默认值为整型的最大值,因此默认优先级比较低。
例如:

//定义日志切面并指定优先级。
@Order(1)
@Aspect
@Component
public class SysLogAspect {

}
//定义缓存切面并指定优先级：
@Order(2)
@Aspect
@Component
public class SysCacheAspect {
    //do something…
}

Spring AOP事务处理

基于@Transactional 注解进行声明式事务管理的实现步骤分为两步：

  • 1.启用声明式事务管理，在项目启动类上添加@EnableTransactionManagement，新版本中也可不添加(例如新版Spring Boot项目).
  • 2.将@Transactional注解添加到合适的业务类或方法上，并设置合适的属性信息.

其代码示例以下：

@Transactional(timeout = 30,readOnly = false,isolation = Isolation.READ_COMMITTED,
                rollbackFor = Throwable.class,propagation = Propagation.REQUIRED)
@Service 
public class SysUserServiceImpl implements SysUserService {
    @Transactional(readOnly = true)
    @Override
    public PageObject<SysUserDeptVo> findPageObjects(String name, Integer pageCurrent) {
        //do something…
    }
}

其中，代码中的@Transactional注解用于描述类或方法，告诉spring框架咱们要在此类的方法执行时进行事务控制，其具体说明以下：

  • 当@Transactional注解应用在类上时表示类中全部方法启动事务管理，而且通常用于事务共性的定义。
  • 当@Transactional描述方法时表示此方法要进行事务管理，假如类和方法上都有@Transactional注解，则方法上的事务特性优先级比较高。

@Transactional 经常使用属性应用说明：

  • timeout：事务的超时时间，默认值为-1,表示没有超时显示。若是配置了具体时间,则超过该时间限制但事务尚未完成，则自动回滚事务。这个时间的记录方式是在事务开启之后到sql语句执行以前。
  • read-only：指定事务是否为只读事务，默认值为 false；为了忽略那些不须要事务的方法，好比读取数据，能够设置read-only为true。对添加，修改，删除业务read-only的值应该为false。
  • rollback-for：用于指定可以触发事务回滚的异常类型，若是有多个异常类型须要指定，各种型之间能够经过逗号分隔。
  • no-rollback- for: 抛出no-rollback-for 指定的异常类型，不回滚事务。
  • isolation事务的隔离级别，默认值采用 DEFAULT。当多个事务并发执行时，可能会出现脏读，不可重复读，幻读等现象时，假如不但愿出现这些现象可考虑修改事务的隔离级别(但隔离级别越高并发就会越小，性能就会越差).
    • *

Spring 业务的异步实现
在基于注解方式的配置中，借助@EnableAsync注解进行异步启动声明，Spring Boot版的项目中，将@EnableAsync注解应用到启动类上，代码示例以下：

@EnableAsync //spring容器启动时会建立线程池
@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

在须要异步执行的业务方法上，使用@Async方法进行异步声明。

@Async
@Transactional(propagation = Propagation.REQUIRES_NEW)
@Override
public void saveObject(SysLog entity) {
    System.out.println("SysLogServiceImpl.save:"+Thread.currentThread().getName());
    sysLogDao.insertObject(entity);
    //try{Thread.sleep(5000);}catch(Exception e) {}
}

假如须要获取业务层异步方法的执行结果，可参考以下代码设计进行实现：

@Transactional(propagation = Propagation.REQUIRES_NEW)
@Async
@Override
public Future<Integer> saveObject(SysLog entity) {
    System.out.println("SysLogServiceImpl.save:"+Thread.currentThread().getName());
    int rows=sysLogDao.insertObject(entity);
    //try{Thread.sleep(5000);}catch(Exception e) {}
    return new AsyncResult<Integer>(rows);
}

其中，AsyncResult对象能够对异步方法的执行结果进行封装，假如外界须要异步方法结果时，能够经过Future对象的get方法获取结果。
当咱们须要本身对spring框架提供的链接池进行一些简易配置，能够参考以下代码：

spring:
    task:
        execution:
            pool:
                queue-capacity: 128
                core-size: 5
                max-size: 128
                keep-alive: 60000
            thread-name-prefix: service-task-

Spring 中业务缓存应用实现
启动缓存配置
在项目(SpringBoot项目)的启动类上添加@EnableCaching注解,以启动缓存配置。代码以下：

//@EnableCaching 注解表示启动缓存配置
@EnableCaching
@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

业务方法上应用缓存配置
在须要进行缓存的业务方法上经过@Cacheable注解对方法进行相关描述.表示方法的返回值要存储到Cache中,假如在更新操做时须要将cache中的数据移除,能够在更新方法上使用@CacheEvict注解对方法进行描述：

@Cacheable(value = "menuCache")
@Transactional(readOnly = true)
public List<Map<String,Object>> findObjects() {
    //....
}

其中，value属性的值表示要使用的缓存对象,名字本身指定，其中底层为一个map对象，当向cache中添加数据时，key默认为方法实际参数的组合。
第二步：在相关模块更新时,清除指定缓存数据,代码以下:

@CacheEvict(value="menuCache",allEntries=true)
@Override
public int saveObject(SysDept entity) {...}

其中，allEntries表示清除全部。

文中部份内容摘自:www.cnblogs.com/tanwei81/p/6814022.html --做者：tanwei81

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程