如何自己开发一个springboot-starter
需求：
统一的把返回的报文中的关键字进行替换
比如：把返回的报文里含有“傻逼”文字的替换成**，只要别人引文我们jar包就可以完成。
1.第一步定义项目
备注：有个不成文的规定
1.一般非官方开发的stater 格式是xxx-spring-boot-starter
2.官方的都是spring-boot-starter-xxx
新建一个空白的项目叫replace-spring-boot-starter
2.添加相关依赖
下面展示一些 内联代码片。
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>org.example</groupId>
<artifactId>replace-spring-boot-starter</artifactId>
<version>1.0-SNAPSHOT</version>
<!-- springboot父工程必须添加-->
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.5.1</version>
</parent>
<dependencies>
<!--引入这个依赖，当我们在配置文件写参数会有自动提示-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-configuration-processor</artifactId>
<optional>true</optional>
</dependency>
<!-- 写starter必须引入下面依赖-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-autoconfigure</artifactId>
</dependency>
<!-- 定义一个web工程-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<!-- 需要用到切面-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-aop</artifactId>
</dependency>
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>1.2.76</version>
</dependency>
</dependencies>
<!-- 打包成jar包给第三方用，必须用下面的编译插件。-->
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<configuration>
<source>1.8</source> <!--指明源码用的Jdk版本-->
<target>1.8</target> <!--指明打包后的Jdk版本-->
</configuration>
</plugin>
</plugins>
</build>
</project>
3.写一个Properties配置类
package com.replace;
import org.springframework.boot.context.properties.ConfigurationProperties;
//@ConfigurationProperties(prefix = "demo") 它可以把相同前缀的配置信息通过配置项名称映射成实体类，比如我们这里指定 prefix = "demo" 这样，我们就能将以demo为前缀的配置项拿到了。
// ps：其实这个注解很强大，它不但能映射成String或基本类型的变量。还可以映射为List，Map等数据结构。
@ConfigurationProperties(prefix = "replace")
public class ReplaceProperties {
private String name="***";
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
4.写一个Configration文件
把我们写的类注入到容器中
package com.replace;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
@EnableConfigurationProperties(ReplaceProperties.class)
public class ReplaceAutoConfigration {
@Bean
public ReplaceAop replaceAop() {
return new ReplaceAop();
}
}
5.定义切面
package com.replace;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;
import javax.servlet.http.HttpServletRequest;
import java.util.Iterator;
import java.util.Set;
@Aspect
public class ReplaceAop {
private static final Log logger = LogFactory.getLog(ReplaceAop.class);
//根据GetMapping，PostMapping，RequestMapping注解找到所有的对外接口
@Pointcut(value = "@annotation(org.springframework.web.bind.annotation.GetMapping)")
public void pointcut1() {
}
@Pointcut(value = "@annotation(org.springframework.web.bind.annotation.PostMapping)")
public void pointcut2() {
}
@Pointcut(value = "@annotation(org.springframework.web.bind.annotation.RequestMapping)")
public void pointcut3() {
}
@Autowired
private ReplaceProperties replaceProperties;
@Around(value = "pointcut1()||pointcut2()||pointcut3()")
public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
try {
logger.info("转换开始");
Object source = joinPoint.proceed();
//获取当前返回报文的对象。class
Class<?> aClass = source.getClass();
// 对象转JSONObject
JSONObject jsonObject = JSON.parseObject(JSON.toJSONString(source));
//替换对象里的value值
replaceValue(jsonObject);
//在转换成原对象
Object target = JSON.parseObject(jsonObject.toJSONString(), aClass);
return target;
} catch (Throwable e) {
e.printStackTrace();
throw e;
} finally {
logger.info("转换结束");
}
}
public void replaceValue(Object objJson) {
//如果obj为json数组
if (objJson instanceof JSONArray) {
JSONArray objArray = (JSONArray) objJson;
for (int i = 0; i < objArray.size(); i++) {
Object object = objArray.get(i);
if (object instanceof String) {
String replace = ((String) object).replace("傻逼", replaceProperties.getName());
objArray.set(i, replace);
} else {
replaceValue(objArray.get(i));
}
}
}
//如果为json对象
else if (objJson instanceof JSONObject) {
JSONObject jsonObject = (JSONObject) objJson;
Set<String> strings = jsonObject.keySet();
Iterator<String> it = strings.iterator();
while (it.hasNext()) {
String key = it.next().toString();
Object object = jsonObject.get(key);
//如果得到的是数组
if (object instanceof JSONArray) {
JSONArray objArray = (JSONArray) object;
replaceValue(objArray);
}
//如果key中是一个json对象
else if (object instanceof JSONObject) {
replaceValue((JSONObject) object);
} else if (object instanceof String) {
String replace = ((String) object).replace("傻逼", replaceProperties.getName());
jsonObject.put(key, replace);
}
}
}
}
}
6.最关键一步定义spring.factories
在resource文件夹下建一个文件夹META-INF，并创建spring.factories文件
org.springframework.boot.autoconfigure.EnableAutoConfiguration=com.replace.ReplaceAutoConfigration
8.目录结构如下
7.进行测试
创建一个maven工程，名称为test。pom文件如下
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.5.2</version>
<relativePath/> <!-- lookup parent from repository -->
</parent>
<groupId>com.example</groupId>
<artifactId>test</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>test</name>
<description>Demo project for Spring Boot</description>
<properties>
<java.version>1.8</java.version>
</properties>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<!--引入我们定义的依赖-->
<dependency>
<groupId>org.example</groupId>
<artifactId>replace-spring-boot-starter</artifactId>
<version>1.0-SNAPSHOT</version>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>
</project>
8.定义一个controller
package com.example.test.controller;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.web.bind.annotation.*;
import java.util.*;
@RestController
public class TestController {
private static Log logger= LogFactory.getLog(TestController.class);
@GetMapping(value = "getCeshi")
@ResponseBody
public ResponseInfo<RplaceUser> getCeshi(){
return getRespone();
}
@PostMapping(value = "postCeshi")
@ResponseBody
public ResponseInfo<RplaceUser> postCeshi(){
return getRespone();
}
@RequestMapping(value = "reuestGet",method = RequestMethod.GET)
@ResponseBody
public ResponseInfo<RplaceUser> reuestGet(){
return getRespone();
}
@RequestMapping(value = "reuestPost",method = RequestMethod.POST)
@ResponseBody
public ResponseInfo<RplaceUser> reuestPost(){
return getRespone();
}
private ResponseInfo<RplaceUser> getRespone(){
RplaceUser user = new RplaceUser();
user.setAge(20);
user.setName("傻逼666");
Map<String,String> map=new HashMap<>();
map.put("傻逼map","傻逼666");
user.setMap(map);
List<String> list=new ArrayList<>();
list.add("傻逼list");
user.setList(list);
Set<String> set=new HashSet<>();
set.add("傻逼set");
user.setSet(set);
ResponseInfo responseInfo=new ResponseInfo("200",user);
return responseInfo;
}
}
9.定义一个复杂的类RepalceUser（返回的实体对象）
package com.example.test.controller;
import java.util.List;
import java.util.Map;
import java.util.Set;
public class RplaceUser {
private String name;
private Integer age;
private Map map;
private Set set;
private List list;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
public Map getMap() {
return map;
}
public void setMap(Map map) {
this.map = map;
}
public Set getSet() {
return set;
}
public void setSet(Set set) {
this.set = set;
}
public List getList() {
return list;
}
public void setList(List list) {
this.list = list;
}
}
10.定义一个泛型ResponseInfo封装RepalceUser（返回的实体对象）
package com.example.test.controller;
import java.io.Serializable;
public class ResponseInfo<T> implements Serializable {
private static final long seriaVersionUID = -3454653246526L;
private String status;
private T data;
public ResponseInfo(String status, T data) {
this.status = status;
this.data = data;
}
public String getStatus() {
return status;
}
public void setStatus(String status) {
this.status = status;
}
public T getData() {
return data;
}
public void setData(T data) {
this.data = data;
}
}
11.applicaton.properties文件写上参数
replace.name=666
11.目录结构
12.返回报文
可以看到value值中的“傻逼”全部被替换
13.springboot的starter启动原理，是如何把我们的bean注入到容器中
springboot默认扫描启动类所在的包下的主类与子类的所有组件，但并没有包括依赖包的中的类，那么依赖包中的bean是如何被发现和加载的？
我们通常在启动类中加@SpringBootApplication这个注解，点进去看
实际上重要的只有三个Annotation：
@Configuration（@SpringBootConfiguration里面还是应用了@Configuration）
@EnableAutoConfiguration
@ComponentScan
@Configuration的作用是被注解的类将成为一个bean配置类。
@ComponentScan的作用就是自动扫描并加载符合条件的组件，比如@Component和@Repository等，最终将这些bean定义加载到spring容器中。
@EnableAutoConfiguration 这个注解的功能很重要，借助@Import的支持，收集和注册依赖包中相关的bean定义。
如上源码，@EnableAutoConfiguration注解引入了@AutoConfigurationPackage和@Import这两个注解。@AutoConfigurationPackage的作用就是自动配置的包，@Import导入需要自动配置的组件。
那问题又来了，要搜集并注册到spring容器的那些beans来自哪里？
进入 AutoConfigurationImportSelector类，我们可以发现SpringFactoriesLoader.loadFactoryNames方法调用loadSpringFactories方法从所有的jar包中读取META-INF/spring.factories文件信息。可以自己打下断点跟一下逻辑。
然后就可以从文件找到配置类，并且执行
14.spring boot把bean注入到容器都有哪些方式
如果要让一个普通类交给Spring容器管理，通常有以下方法：
使用 @Configuration与@Bean 注解
使用@Controller @Service @Repository @Component 注解标注该类，然后启用@ComponentScan自动扫描
使用@Import 方法
springboot中使用了@Import 方法
@EnableAutoConfiguration注解中使用了@Import({AutoConfigurationImportSelector.class})注解，AutoConfigurationImportSelector实现了DeferredImportSelector接口，
DeferredImportSelector接口继承了ImportSelector接口，ImportSelector接口只有一个selectImports方法。
selectImports方法返回一组bean，@EnableAutoConfiguration注解借助@Import注解将这组bean注入到spring容器中，springboot正式通过这种机制来完成bean的注入的。
扫一扫
298
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
