SpringBoot自动装配：从原理到实战的深度解析（附工作常用配置）

作为Java开发者，我们对SpringBoot的“开箱即用”一定不陌生——引入spring-boot-starter-web就能快速搭建Web服务，加个spring-boot-starter-data-redis依赖就能直接用RedisTemplate操作Redis。这背后的核心能力，正是SpringBoot的自动装配（Auto-Configuration） 机制。

不同于Spring传统开发中“XML配置bean”“手动扫描组件”的繁琐流程，自动装配通过“约定优于配置”的思想，帮我们自动完成了90%的基础配置，让开发者能聚焦业务逻辑。

一、先搞懂：自动装配的核心原理是什么？

SpringBoot自动装配的本质，是“通过特定规则，在启动时自动向Spring容器注册符合条件的Bean”，整个过程可拆解为3个关键步骤：触发入口→配置文件解析→条件筛选与Bean注册。

1. 触发入口：@SpringBootApplication注解

我们写SpringBoot启动类时，都会加@SpringBootApplication注解，这个注解看似简单，实则是自动装配的“总开关”——它是一个复合注解，核心由3个注解组成：

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
// 1. 开启组件扫描（扫描当前类所在包及子包的@Component、@Service等注解）
@ComponentScan(excludeFilters = {
    @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
    @Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class)
})
// 2. 开启自动装配（核心！）
@EnableAutoConfiguration
// 3. 允许在启动类上定义配置（如@Bean）
@Configuration(proxyBeanMethods = false)
public @interface SpringBootApplication {
    // ... 省略属性
}

其中，@EnableAutoConfiguration 是自动装配的“启动键”，它又依赖两个关键注解：

• @AutoConfigurationPackage：将启动类所在的包标记为“自动配置包”，后续自动装配时会优先扫描该包下的组件；
• @Import(AutoConfigurationImportSelector.class)：这是最核心的逻辑——通过AutoConfigurationImportSelector类，动态导入SpringBoot预定义的“自动配置类”（如WebMvcAutoConfiguration、RedisAutoConfiguration）。

2. 配置文件解析：META-INF/spring.factories

SpringBoot怎么知道要导入哪些“自动配置类”？答案藏在一个约定好的配置文件里——META-INF/spring.factories。

这个文件由SpringBoot的 starter 依赖（如spring-boot-autoconfigure）提供，里面以键值对的形式，列出了所有“候选自动配置类”，格式如下：

# 自动配置类列表（部分关键类）
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
org.springframework.boot.autoconfigure.web.servlet.WebMvcAutoConfiguration,\
org.springframework.boot.autoconfigure.data.redis.RedisAutoConfiguration,\
org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration,\
org.springframework.boot.autoconfigure.cache.CacheAutoConfiguration

当SpringBoot启动时，AutoConfigurationImportSelector会读取这个文件，把所有配置的自动配置类加载到内存中，作为“候选Bean定义”。

3. 条件筛选：@Conditional注解家族的“准入规则”

加载了候选自动配置类后，SpringBoot并不会把它们全部注册到容器中——而是通过@Conditional注解家族做“条件筛选”，只有满足条件的类才会最终生效。

这也是自动装配“灵活适配”的关键：比如“只有当classpath下有Servlet.class时，WebMvcAutoConfiguration才生效”“只有当容器中没有RedisTemplate Bean时，才自动注册默认的RedisTemplate”。

工作中最常见的@Conditional衍生注解有这些，必须牢记：

注解	生效条件	工作场景示例
@ConditionalOnClass	classpath下存在指定类	引入spring-boot-starter-web后，才加载WebMvcAutoConfiguration（因存在Servlet.class）
@ConditionalOnMissingClass	classpath下不存在指定类	若项目中没有引入FastJson，才使用默认的Jackson序列化
@ConditionalOnBean	容器中已存在指定Bean	若用户自己定义了DataSource Bean，就不加载默认的DataSourceAutoConfiguration
@ConditionalOnMissingBean	容器中不存在指定Bean	若用户没定义RedisTemplate，才自动注册默认的RedisTemplate
@ConditionalOnProperty	配置文件中存在指定属性，且值匹配	配置spring.cache.type=redis时，才加载RedisCacheConfiguration
@ConditionalOnWebApplication	当前应用是Web应用（Servlet或Reactive）	只有Web项目才加载DispatcherServletAutoConfiguration

举个实际例子：RedisAutoConfiguration的部分源码，就能看到这些注解的应用：

// 只有当classpath下有RedisOperations.class（引入redis依赖后才存在）时生效
@ConditionalOnClass(RedisOperations.class)
// 只有当配置文件中有spring.redis.*相关配置时才生效
@EnableConfigurationProperties(RedisProperties.class)
@Import({ LettuceConnectionConfiguration.class, JedisConnectionConfiguration.class })
public class RedisAutoConfiguration {

    // 若容器中没有RedisTemplate Bean，才注册默认的RedisTemplate
    @Bean
    @ConditionalOnMissingBean(name = "redisTemplate")
    public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        RedisTemplate<Object, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(redisConnectionFactory);
        return template;
    }

    // 若容器中没有StringRedisTemplate Bean，才注册默认的StringRedisTemplate
    @Bean
    @ConditionalOnMissingBean
    public StringRedisTemplate stringRedisTemplate(RedisConnectionFactory redisConnectionFactory) {
        return new StringRedisTemplate(redisConnectionFactory);
    }
}

通过这三步（触发入口→解析配置→条件筛选），SpringBoot就完成了“按需自动装配”——你引入什么依赖，就加载对应的配置；你自定义了Bean，就覆盖默认配置。

二、必须掌握：自动装配的核心特性与优点

理解原理后，我们再总结自动装配的核心特性——这些特性正是它能大幅提升开发效率的原因，也是工作中解决配置问题的关键思路。

1. 核心特性

（1）约定优于配置（Convention over Configuration）

这是自动装配的核心思想：SpringBoot定义了一套默认约定，开发者无需额外配置就能满足大部分场景。

• 约定1：配置文件默认放在src/main/resources/application.properties/yaml；
• 约定2：Bean的扫描范围默认是启动类所在包及子包；
• 约定3：starter依赖命名遵循spring-boot-starter-xxx，自动关联对应的配置类；
• 约定4：默认端口8080、默认数据源驱动匹配依赖、默认日志框架Logback。

比如你引入spring-boot-starter-web，不用配置DispatcherServlet，SpringBoot会默认注册；不用配置ViewResolver，会默认用InternalResourceViewResolver处理JSP/Thymeleaf。

（2）可扩展性：支持“自定义覆盖默认”

自动装配不是“一刀切”，而是留足了扩展空间——开发者可以通过3种方式覆盖默认配置，满足个性化需求：

1. 自定义Bean覆盖：若你在配置类中定义了和自动配置类同名的Bean（如redisTemplate），Spring会优先使用你的Bean，自动配置的Bean会失效（因@ConditionalOnMissingBean）；
2. 配置文件覆盖：通过application.properties/yaml修改自动配置类的属性（如spring.redis.host=192.168.1.100，覆盖默认的localhost）；
3. 排除不需要的自动配置类：通过@SpringBootApplication(exclude = {DataSourceAutoConfiguration.class})，排除不需要的自动配置（如项目不用数据库，排除数据源配置）。

（3）按需加载（On-Demand Loading）

只有当满足“条件”时，自动配置类才会生效——避免了无用配置占用资源。

• 比如没引入spring-boot-starter-data-redis，RedisAutoConfiguration就不会加载；
• 比如配置了spring.datasource.url，DataSourceAutoConfiguration才会注册默认数据源；
• 比如是非Web项目，所有Web相关的自动配置类（如WebMvcAutoConfiguration）都会跳过。

2. 相比传统Spring的优点

对比维度	传统Spring开发	SpringBoot自动装配	工作效率提升点
依赖管理	需手动引入所有依赖（如spring-web、spring-context），且要匹配版本	引入一个starter即可（如spring-boot-starter-web），版本由SpringBoot统一管理	避免版本冲突，减少依赖配置时间
Bean配置	需XML或@Configuration手动注册Bean（如DataSource、RedisTemplate）	自动注册默认Bean，按需覆盖即可	减少80%的基础Bean配置代码
环境适配	需为开发/测试/生产环境写多套配置文件，手动切换	支持profile多环境配置（如application-dev.yml），启动时指定即可	多环境切换更灵活，减少配置冗余
部署与启动	需手动打包成WAR，部署到Tomcat	可打包成JAR，内置Tomcat，直接java -jar启动	简化部署流程，适合微服务容器化部署

举个工作中的例子：传统Spring搭建Web项目，需要手动引入spring-web、spring-webmvc、tomcat-embed-core等依赖，还要配置DispatcherServlet、ContextLoaderListener；而SpringBoot只需引入spring-boot-starter-web，启动类加个注解，直接运行就能访问接口——这就是自动装配带来的效率提升。

三、工作必备：自动装配常用配置项与说明

在实际开发中，我们不需要重复造轮子，而是基于自动装配的默认配置，通过application.properties/yaml修改属性，快速适配业务需求。下面整理了工作中最常用的几类自动配置配置项，附详细说明和示例。

1. Web相关自动配置（WebMvcAutoConfiguration）

对应依赖：spring-boot-starter-web，核心配置前缀spring.mvc、server。

配置项	说明	默认值	工作场景示例
server.port	服务端口号	8080	开发环境改端口避免冲突：server.port=8081
server.servlet.context-path	项目上下文路径（URL前缀）	/	多服务部署时区分：server.servlet.context-path=/user-service
spring.mvc.view.prefix	视图前缀（Thymeleaf/JSP）	无	Thymeleaf配置：spring.mvc.view.prefix=classpath:/templates/
spring.mvc.view.suffix	视图后缀	无	Thymeleaf配置：spring.mvc.view.suffix=.html
spring.mvc.static-path-pattern	静态资源访问路径（如JS/CSS/图片）	/**	限制静态资源路径：spring.mvc.static-path-pattern=/static/**
server.tomcat.max-threads	Tomcat最大工作线程数	200	高并发服务调大：server.tomcat.max-threads=500
server.tomcat.connection-timeout	Tomcat连接超时时间（毫秒）	20000	避免长连接占用：server.tomcat.connection-timeout=10000

示例（application.yml）：

server:
  port: 8081
  servlet:
    context-path: /order-service
  tomcat:
    max-threads: 500
    connection-timeout: 10000
spring:
  mvc:
    view:
      prefix: classpath:/templates/
      suffix: .html
    static-path-pattern: /static/**

2. Redis相关自动配置（RedisAutoConfiguration）

对应依赖：spring-boot-starter-data-redis，核心配置前缀spring.redis。

配置项	说明	默认值	工作场景示例
spring.redis.host	Redis服务器地址	localhost	连接远程Redis：spring.redis.host=192.168.1.100
spring.redis.port	Redis端口号	6379	非默认端口：spring.redis.port=6380
spring.redis.password	Redis密码（若有）	无	带密码的Redis：spring.redis.password=123456
spring.redis.database	Redis数据库索引（0-15）	0	多业务分库：spring.redis.database=1
spring.redis.timeout	连接超时时间（毫秒）	2000	网络差时调大：spring.redis.timeout=5000
spring.redis.lettuce.pool.max-active	连接池最大活跃连接数	8	高并发调大：spring.redis.lettuce.pool.max-active=16
spring.redis.lettuce.pool.max-idle	连接池最大空闲连接数	8	保持连接池效率：spring.redis.lettuce.pool.max-idle=4
spring.redis.lettuce.pool.min-idle	连接池最小空闲连接数	2	避免频繁创建连接：spring.redis.lettuce.pool.min-idle=2

注意：SpringBoot 2.x后默认使用Lettuce作为Redis客户端（替代Jedis），若需切换回Jedis，需排除Lettuce依赖，引入Jedis依赖：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
    <exclusions>
        <exclusion>
            <groupId>io.lettuce</groupId>
            <artifactId>lettuce-core</artifactId>
        </exclusion>
    </exclusions>
</dependency>
<!-- 引入Jedis -->
<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
</dependency>

此时配置项会变为spring.redis.jedis.pool.*。

3. 数据源相关自动配置（DataSourceAutoConfiguration）

对应依赖：spring-boot-starter-jdbc或spring-boot-starter-data-jpa，核心配置前缀spring.datasource。

配置项	说明	默认值	工作场景示例
spring.datasource.url	数据库连接URL	无	MySQL：spring.datasource.url=jdbc:mysql://localhost:3306/test?useSSL=false&serverTimezone=UTC
spring.datasource.username	数据库用户名	无	spring.datasource.username=root
spring.datasource.password	数据库密码	无	spring.datasource.password=123456
spring.datasource.driver-class-name	数据库驱动类名	自动匹配	MySQL 8.x需指定：spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.hikari.maximum-pool-size	Hikari连接池最大连接数（默认用Hikari）	10	高并发调大：spring.datasource.hikari.maximum-pool-size=20
spring.datasource.hikari.minimum-idle	Hikari连接池最小空闲连接数	10	spring.datasource.hikari.minimum-idle=5
spring.datasource.hikari.idle-timeout	Hikari连接池空闲连接超时时间（毫秒）	600000（10分钟）	避免空闲连接占用：spring.datasource.hikari.idle-timeout=300000（5分钟）
spring.datasource.hikari.connection-timeout	Hikari连接池获取连接超时时间（毫秒）	30000（30秒）	快速失败：spring.datasource.hikari.connection-timeout=10000（10秒）
spring.datasource.hikari.max-lifetime	Hikari连接池连接最大生命周期（毫秒）	1800000（30分钟）	定期更换连接：spring.datasource.hikari.max-lifetime=1200000（20分钟）

示例（MySQL 8.x + Hikari）：

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/order_db?useSSL=false&serverTimezone=UTC&allowPublicKeyRetrieval=true
    username: root
    password: 123456
    driver-class-name: com.mysql.cj.jdbc.Driver
    hikari:
      maximum-pool-size: 20
      minimum-idle: 5
      idle-timeout: 300000
      connection-timeout: 10000
      max-lifetime: 1200000

注意：若需切换其他连接池（如Druid），需引入Druid的starter依赖（如com.alibaba:druid-spring-boot-starter），配置项会变为spring.datasource.druid.*，例如：

spring:
  datasource:
    druid:
      url: jdbc:mysql://localhost:3306/order_db?useSSL=false&serverTimezone=UTC
      username: root
      password: 123456
      initial-size: 5
      max-active: 20
      min-idle: 3
      max-wait: 10000

4. 缓存相关自动配置（CacheAutoConfiguration）

对应依赖：spring-boot-starter-cache，需配合具体缓存实现（如Redis、Caffeine），核心配置前缀spring.cache。

配置项	说明	默认值	工作场景示例
spring.cache.type	缓存类型（支持REDIS、CAFFEINE、SIMPLE等）	无（需指定）	使用Redis作为缓存：spring.cache.type=REDIS
spring.cache.redis.time-to-live	Redis缓存默认过期时间	无（永不过期）	设置1小时过期：spring.cache.redis.time-to-live=3600000
spring.cache.redis.key-prefix	Redis缓存key前缀	无	加业务前缀区分：spring.cache.redis.key-prefix=order_
spring.cache.redis.cache-null-values	是否缓存null值（避免缓存穿透）	false	开启防穿透：spring.cache.redis.cache-null-values=true
spring.cache.caffeine.spec	Caffeine缓存配置（如最大容量、过期时间）	无	最大1000个，10分钟过期：spring.cache.caffeine.spec=maximumSize=1000,expireAfterWrite=600s

示例（Redis缓存）：

spring:
  cache:
    type: REDIS
    redis:
      time-to-live: 3600000
      key-prefix: order_
      cache-null-values: true
    # 开启缓存注解支持（需在启动类加@EnableCaching）
  redis:
    host: 192.168.1.100
    port: 6379

5. 日志相关自动配置（LoggingAutoConfiguration）

SpringBoot默认使用Logback作为日志框架，无需额外依赖，核心配置前缀logging。

配置项	说明	默认值	工作场景示例
logging.level.root	根日志级别（TRACE、DEBUG、INFO、WARN、ERROR）	INFO	开发环境开启DEBUG：logging.level.root=DEBUG
logging.level.com.example	指定包的日志级别	继承root级别	业务包开启DEBUG：logging.level.com.example=DEBUG
logging.file.name	日志文件路径及名称	无（控制台输出）	输出到文件：logging.file.name=/var/log/app/order-service.log
logging.file.max-size	单个日志文件最大大小	10MB	调大到50MB：logging.file.max-size=50MB
logging.file.max-history	日志文件保留天数	7天	保留30天：logging.file.max-history=30

示例：

logging:
  level:
    root: INFO
    com.example.order: DEBUG
    org.springframework.web: WARN
  file:
    name: /var/log/app/order-service.log
    max-size: 50MB
    max-history: 30

若需自定义日志格式（如包含线程名、日志时间），可在src/main/resources下新建logback-spring.xml文件，覆盖默认配置，例如：

<?xml version="1.0" encoding="UTF-8"?>
<configuration>
    <appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <!-- 日志格式：时间 [线程名] 级别 包名 - 日志内容 -->
            <pattern>%d{yyyy-MM-dd HH:mm:ss} [%thread] %-5level %logger{36} - %msg%n</pattern>
        </encoder>
    </appender>
    <root level="INFO">
        <appender-ref ref="CONSOLE" />
    </root>
    <logger name="com.example.order" level="DEBUG" additivity="false">
        <appender-ref ref="CONSOLE" />
    </logger>
</configuration>

四、实战场景：自动装配的常见问题与解决方案

理解了原理和配置，还要能解决工作中遇到的实际问题。下面整理了3个高频自动装配场景，附问题现象、排查思路和解决方案。

场景1：自定义RedisTemplate后，自动装配的StringRedisTemplate失效？

问题现象

在配置类中自定义了RedisTemplate Bean后，发现StringRedisTemplate无法注入，报No qualifying bean of type 'org.springframework.data.redis.core.StringRedisTemplate' available。

排查思路

查看RedisAutoConfiguration源码，发现StringRedisTemplate的注册条件是@ConditionalOnMissingBean（无默认Bean时才注册），但这个注解默认不指定Bean名称时，会匹配所有同类型Bean吗？
不对——@ConditionalOnMissingBean在方法上时，若未指定name属性，只会检查“是否存在该方法返回类型的Bean”。而RedisTemplate和StringRedisTemplate是不同类型（StringRedisTemplate extends RedisTemplate<String, String>），理论上不会冲突。

进一步排查发现：自定义RedisTemplate时，可能误将方法返回类型写成了StringRedisTemplate，或在@Bean注解中指定了name="stringRedisTemplate"，导致覆盖了自动装配的StringRedisTemplate。

解决方案

1. 确保自定义RedisTemplate的方法返回类型正确，不与StringRedisTemplate冲突：

@Configuration
public class RedisConfig {
    // 正确：返回RedisTemplate，不影响StringRedisTemplate
    @Bean
    public RedisTemplate<Object, Object> customRedisTemplate(RedisConnectionFactory factory) {
        RedisTemplate<Object, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(factory);
        // 自定义序列化配置（如用FastJson2JsonRedisSerializer）
        template.setValueSerializer(new FastJson2JsonRedisSerializer<>(Object.class));
        return template;
    }
}

2. 若需自定义StringRedisTemplate，单独写一个Bean方法，避免覆盖默认Bean：

@Bean
public StringRedisTemplate customStringRedisTemplate(RedisConnectionFactory factory) {
    StringRedisTemplate template = new StringRedisTemplate(factory);
    template.setValueSerializer(new StringRedisSerializer());
    return template;
}

场景2：引入mybatis-spring-boot-starter后，数据源自动装配失败？

问题现象

引入mybatis-spring-boot-starter后，启动报错Failed to configure a DataSource: 'url' attribute is not specified and no embedded datasource could be configured，但已在application.yml中配置了spring.datasource.url。

排查思路

1. 首先检查配置文件路径是否正确（必须在src/main/resources下，且文件名是application.yml/application.properties）；
2. 检查配置项是否有拼写错误（如spring.datasource.url写成spring.datasource.uri）；
3. 查看DataSourceAutoConfiguration的生效条件：是否引入了数据源依赖（spring-boot-starter-jdbc）？mybatis-spring-boot-starter会间接依赖spring-boot-starter-jdbc，但需确认依赖是否下载成功（查看pom.xml中是否有红色波浪线，或target/dependency目录下是否有spring-jdbc相关jar）；
4. 检查是否有其他配置类排除了DataSourceAutoConfiguration（如@SpringBootApplication(exclude = DataSourceAutoConfiguration.class)），若有则移除排除。

解决方案

1. 确认配置文件正确，示例：

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/mybatis_db?useSSL=false&serverTimezone=UTC
    username: root
    password: 123456
    driver-class-name: com.mysql.cj.jdbc.Driver

2. 若依赖未下载成功，执行mvn clean install重新拉取依赖；
3. 若排除了DataSourceAutoConfiguration，删除exclude属性，确保自动配置类正常加载。

场景3：使用@Cacheable注解后，缓存未生效？

问题现象

在Service方法上添加@Cacheable(value = "orderCache", key = "#orderId")后，多次调用该方法，发现每次都执行数据库查询，缓存未生效。

排查思路

1. 检查是否在启动类上添加了@EnableCaching注解——这是开启缓存注解支持的必要条件，缺少则@Cacheable不生效；
2. 检查spring.cache.type是否配置正确（如使用Redis缓存需配置spring.cache.type=REDIS），若未配置，SpringBoot会默认使用SimpleCacheManager（内存缓存，重启后失效，且不支持分布式）；
3. 检查方法参数是否支持序列化（如orderId是自定义对象，需实现Serializable接口，否则无法作为缓存key）；
4. 检查方法是否为“非public”——Spring AOP默认只对public方法生效，private/protected方法的@Cacheable注解会失效。

解决方案

1. 在启动类添加@EnableCaching：

@SpringBootApplication
@EnableCaching // 开启缓存支持
public class OrderServiceApplication {
    public static void main(String[] args) {
        SpringApplication.run(OrderServiceApplication.class, args);
    }
}

2. 配置正确的缓存类型（以Redis为例）：

spring:
  cache:
    type: REDIS
    redis:
      time-to-live: 3600000
  redis:
    host: 192.168.1.100
    port: 6379

3. 确保方法为public，且参数支持序列化：

@Service
public class OrderService {
    // 正确：public方法，参数为Long（支持序列化）
    @Cacheable(value = "orderCache", key = "#orderId")
    public Order getOrderById(Long orderId) {
        // 数据库查询逻辑
        return orderMapper.selectById(orderId);
    }
}

五、总结：自动装配的核心思想与实践建议

SpringBoot自动装配的本质，是“约定优于配置+条件筛选+可扩展”的组合——通过约定减少重复配置，通过条件筛选实现按需加载，通过自定义覆盖满足个性化需求。它不是“黑魔法”，而是Spring对“简化开发”理念的极致实现。

在工作中使用自动装配，建议遵循以下3个原则：

1. 优先用默认配置：大部分场景下，SpringBoot的默认配置已满足需求（如默认的Hikari连接池、RedisTemplate），不要盲目自定义，避免增加复杂度；
2. 理解配置项含义再修改：修改application.yml时，先搞懂配置项的作用（如spring.redis.lettuce.pool.max-active是连接池最大活跃数），避免凭感觉配置导致问题；
3. 遇到问题查源码：自动装配相关问题（如Bean未注册、配置不生效），优先查看对应的自动配置类源码（如RedisAutoConfiguration），通过@Conditional注解判断生效条件，快速定位问题。

掌握自动装配，不仅能大幅提升开发效率，更能帮你理解SpringBoot的设计思想——这也是从“会用框架”到“懂框架”的关键一步。

---

Studying will never be ending.

▲如有纰漏，烦请指正~~