从Spring迁移到Spring Boot的方法步骤

从Spring迁移到SpringBoot主要需要将项目的配置文件进行改造，主要的改造点是将原来手动配置的部分，改为使用SpringBoot提供的依赖自动配置的机制。下面是从Spring迁移到SpringBoot的方法步骤：

1. 配置文件的改造

SpringBoot采用了约定优于配置的原则，它提供了一些默认的配置，让我们可以快速地启动和搭建项目。因此，在迁移的过程中，需要进行配置文件的改造，使其符合SpringBoot的配置规范。

1.1 将原来手动配置的部分改为自动配置

Spring提供了一系列的自动配置模块，称为starter，它们会自动配置Spring应用程序所需的所有常见属性。在迁移的过程中，需要将原来手动配置的部分，改为使用SpringBoot提供的依赖自动配置的机制。

比如，我们原来手动配置了一个JdbcTemplate，代码如下所示：

@Configuration
public class JdbcTemplateConfig {

    @Autowired
    private DataSource dataSource;

    @Bean(name = "jdbcTemplate")
    public JdbcTemplate jdbcTemplate() {
        JdbcTemplate jdbcTemplate = new JdbcTemplate();
        jdbcTemplate.setDataSource(dataSource);
        return jdbcTemplate;
    }

}

在SpringBoot中，我们只需要在pom.xml中引入spring-boot-starter-jdbc依赖，就可以自动配置一个JdbcTemplate了，不需要手动配置。代码如下所示：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>

1.2 改配置文件的命名和位置

SpringBoot采用的默认配置文件是properties文件或者是yml文件，而且文件名和位置都有一定的约定。比如，我们的主配置文件名应该为application.properties或者application.yml，位置应该放在classpath:根目录下。

1.3 配置文件中的属性改为SpringBoot的属性

在SpringBoot中，有很多默认的属性值。我们要用这些属性来替换原来手动设置的那些属性。

2. 代码的改造

在迁移的过程中，需要对一些代码进行修改，以适应SpringBoot的规范。

2.1 修改启动类

SpringBoot的启动类不同于原来的启动类，需要进行修改，使其符合SpringBoot的规范。

比如，我们原来的启动类如下所示：

@Configuration
@ComponentScan
@EnableAutoConfiguration
public class Application {

    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }

}

在SpringBoot中，我们只需要在pom.xml中引入spring-boot-starter-web依赖，就可以使用@SpringBootApplication注解代替原来的@Configuration、@ComponentScan、@EnableAutoConfiguration注解。代码如下所示：

@SpringBootApplication
public class Application {

    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }

}

2.2 修改Controller和Service的注解

在SpringBoot中，我们可以使用@RestController代替原来的@Controller和@ResponseBody注解，用@Service代替原来的@Service注解，用@Autowired代替原来的@Inject和@Resource注解。

比如，我们原来的Controller代码如下所示：

@Controller
@RequestMapping("/user")
public class UserController {

    @Inject
    private UserService userService;

    @ResponseBody
    @RequestMapping("/list")
    public List<User> list() {
        return userService.list();
    }

}

在SpringBoot中，我们需要将代码改为如下所示：

@RestController
@RequestMapping("/user")
public class UserController {

    @Autowired
    private UserService userService;

    @RequestMapping("/list")
    public List<User> list() {
        return userService.list();
    }

}

示例：

示例1: SpringBoot整合Redis

现在我们有一个使用Spring开发的项目，而我们想把这个项目转为使用SpringBoot开发。首先我们来看看如何整合Redis。

将pom.xml中的spring-data-redis、jedis、fastjson依赖改为如下所示：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
</dependency>

<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
</dependency>

新建RedisConfig类，代码如下所示：

@Configuration
public class RedisConfig {

    @Value("${redis.host}")
    private String host;

    @Value("${redis.port}")
    private int port;

    @Value("${redis.timeout}")
    private int timeout;

    @Value("${redis.pool.max-total}")
    private int maxTotal;

    @Value("${redis.pool.max-idle}")
    private int maxIdle;

    @Value("${redis.pool.max-wait}")
    private int maxWaitMillis;

    @Bean
    public JedisPool redisPool() {
        JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
        jedisPoolConfig.setMaxTotal(maxTotal);
        jedisPoolConfig.setMaxIdle(maxIdle);
        jedisPoolConfig.setMaxWaitMillis(maxWaitMillis);

        return new JedisPool(jedisPoolConfig, host, port, timeout);
    }

    @Bean
    public RedisTemplate<String, Object> redisTemplate() {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(redisConnectionFactory());
        template.setDefaultSerializer(fastJson2JsonRedisSerializer());
        template.setKeySerializer(new StringRedisSerializer());
        return template;
    }

    @Bean
    public RedisConnectionFactory redisConnectionFactory() {
        JedisConnectionFactory jedisConnectionFactory = new JedisConnectionFactory();
        jedisConnectionFactory.setHostName(host);
        jedisConnectionFactory.setPort(port);
        jedisConnectionFactory.setPoolConfig(jedisPoolConfig());
        jedisConnectionFactory.setTimeout(timeout);
        jedisConnectionFactory.afterPropertiesSet();

        return jedisConnectionFactory;
    }

    @Bean
    public Pool<Jedis> jedisPool() {
        JedisPoolConfig poolConfig = new JedisPoolConfig();
        poolConfig.setMaxTotal(maxTotal);
        poolConfig.setMaxIdle(maxIdle);
        poolConfig.setMaxWaitMillis(maxWaitMillis);

        JedisPool jedisPool = new JedisPool(poolConfig, host, port, timeout);
        return jedisPool;
    }

    @Bean
    public RedisSerializer<Object> fastJson2JsonRedisSerializer() {
        FastJson2JsonRedisSerializer<Object> serializer = new FastJson2JsonRedisSerializer<>(Object.class);
        return serializer;
    }

    @Bean
    public JedisPoolConfig jedisPoolConfig() {
        JedisPoolConfig config = new JedisPoolConfig();
        config.setMaxTotal(maxTotal);
        config.setMaxIdle(maxIdle);
        config.setMaxWaitMillis(maxWaitMillis);
        return config;
    }
}

在application.properties中添加如下配置：

redis.host=127.0.0.1
redis.port=6379
redis.timeout=6000
redis.pool.max-total=1024
redis.pool.max-idle=200
redis.pool.max-wait=1000

修改UserController代码，让它使用Redis缓存数据：

@RestController
@RequestMapping("/user")
public class UserController {
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    @Autowired
    private UserService userService;

    @RequestMapping("/list")
    public List<User> list() {
        String key = "user:list";
        ValueOperations<String, Object> valueOps = redisTemplate.opsForValue();
        // 先从缓存中获取数据，如果缓存中有，则不查询数据库
        Object userObj = valueOps.get(key);
        if (userObj != null) {
            List<User> users = (List<User>) userObj;
            return users;
        }

        List<User> users = userService.list();
        valueOps.set(key, users);
        return users;
    }
}

示例2: SpringBoot整合MyBatis

现在我们有一个使用Spring开发的项目，而我们想把这个项目转为使用SpringBoot开发。接下来我们来看看如何整合MyBatis。

将pom.xml中的spring-boot-starter-jdbc依赖改为如下所示：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>

将pom.xml中的mysql-connector-java依赖改为如下所示：

<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
</dependency>

创建一个DataSourceConfig类，代码如下所示：

@Configuration
@MapperScan(basePackages = "com.example.mapper") // 扫描所有Mapper接口
public class DataSourceConfig {
    @Value("${jdbc.driverClassName}")
    private String driverClassName;

    @Value("${jdbc.username}")
    private String username;

    @Value("${jdbc.password}")
    private String password;

    @Value("${jdbc.url}")
    private String url;

    @Bean
    public DataSource dataSource() {
        DriverManagerDataSource dataSource = new DriverManagerDataSource();
        dataSource.setDriverClassName(driverClassName);
        dataSource.setUsername(username);
        dataSource.setPassword(password);
        dataSource.setUrl(url);
        return dataSource;
    }

}

将mybatis的配置文件mybatis-config.xml中的内容改为如下所示：

<?xml version="1.0" encoding="UTF-8"?>
<configuration>
    <settings>
        <setting name="mapUnderscoreToCamelCase" value="true"/>
    </settings>
</configuration>

修改UserService代码，让它使用MyBatis查询数据库：

@Service
public class UserService {

    @Autowired
    private UserMapper userMapper;

    public List<User> list() {
        return userMapper.list();
    }
}

创建一个UserMapper接口，代码如下所示：

@Mapper
public interface UserMapper {
    List<User> list();
}

在application.properties中添加如下配置：

jdbc.driverClassName=com.mysql.jdbc.Driver
jdbc.username=root
jdbc.password=123456
jdbc.url=jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=utf-8&allowMultiQueries=true

修改UserController代码，让它使用MyBatis查询数据库：

@RestController
@RequestMapping("/user")
public class UserController {

    @Autowired
    private UserService userService;

    @RequestMapping("/list")
    public List<User> list() {
        return userService.list();
    }

}

这样，我们就完成了将Spring项目迁移到SpringBoot并整合Redis和MyBatis的过程。

本站文章如无特殊说明，均为本站原创，如若转载，请注明出处：从Spring迁移到Spring Boot的方法步骤 - Python技术站