花2天时间研究了下Spring Boot：我拆分成了下面这些信息

最新推荐文章于 2024-11-27 17:07:52 发布
最新推荐文章于 2024-11-27 17:07:52 发布
阅读量346 收藏
点赞数
分类专栏： 经验总结 文章标签： 程序人生 经验分享 java spring boot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_42032431/article/details/107838725
版权
本文详细介绍如何使用SpringBoot框架解决单体应用的复杂性和维护难题，包括快速搭建微服务、集成日志、数据库动态切换、JTA事务管理及监控部署，最后介绍SpringBoot Admin的配置方法。

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

当单体架构到达一定规模时，修正bug和正确的添加新功能变的非常困难，并且很耗时。单体应用模块之间的强依赖很可能因为某一模块而导致整个应用宕机，很影响开发效率。所以说复杂而笨重的单体式应用就非常不适合持续性开发了。这时候Spring
Boot完美解决了复杂臃肿的单体式应用出现的问题。它对开发者异常友好，很容易常见一个单模块的Spring应用、内置了常见的web服务器，模块最终可以打包成jar包启动、提供了很多可以选择的’starter’、简化了Spring大量配置等…

当前开发系统（百万行代码）就存在单体式应用的问题，花了2天时间研究了下Spring Boot，准备后期拆分成Spring Boot微服务架构

Spring Boot框架搭建

一、创建Spring Boot

IDEA编辑器的话，只需要File–>New–>Project–>Spring Initializr 需要的依赖选择后就可以创建一个Spring Boot应用了。这个时候就可以启动应用程序了，代码块：

@Controller
@EnableAutoConfiguration
public class SampleController {

    @RequestMapping("/")
    @ResponseBody
    String home() {
        return "Hello World!";
    }

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

运行SampleController.java后，访问http://localhost:8080，页面会返回Hello World!结果。这样一个基本的微服务就搭建成功了。比普通的web框架简易太多了，再也不用管理Tomcat和Spring的大量配置了！

二、Spring Boot集成log4j2

添加POM依赖：

<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter</artifactId>
	<exclusions>
		<exclusion>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-logging</artifactId>
		</exclusion>
	</exclusions>
</dependency>
<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-log4j2</artifactId>
</dependency>

添加log4j2.xml配置文件：

<?xml version="1.0" encoding="UTF-8"?>
<configuration status="warn">
    <appenders>
        <console name="Console" target="SYSTEM_OUT">
            <PatternLayout pattern="[%d{yyyy-MM-dd HH:mm:ss:SSS}] [%p] - [Thread:%t] -%l - %m%n"/>
        </console>

        <RollingFile name="RollingFileInfo" fileName="/Users/tian_dd/logs/spring-boot/info.log"
                     filePattern="/Users/tian_dd/logs/spring-boot/$${date:yyyy-MM}/info-%d{yyyy-MM-dd}-%i.log">
            <Filters>
                <ThresholdFilter level="INFO"/>
                <ThresholdFilter level="WARN" onMatch="DENY" onMismatch="NEUTRAL"/>
            </Filters>
            <PatternLayout pattern="[%d{yyyy-MM-dd HH:mm:ss:SSS}] [%p] - [Thread:%t] -%l - %m%n"/>
            <Policies>
                <TimeBasedTriggeringPolicy/>
                <SizeBasedTriggeringPolicy size="100 MB"/>
            </Policies>
        </RollingFile>

        <RollingFile name="RollingFileWarn" fileName="/Users/tian_dd/logs/spring-boot/warn.log"
                     filePattern="/Users/tian_dd/logs/spring-boot/$${date:yyyy-MM}/warn-%d{yyyy-MM-dd}-%i.log">
            <Filters>
                <ThresholdFilter level="WARN"/>
                <ThresholdFilter level="ERROR" onMatch="DENY" onMismatch="NEUTRAL"/>
            </Filters>
            <PatternLayout pattern="[%d{yyyy-MM-dd HH:mm:ss:SSS}] [%p] - [Thread:%t] -%l - %m%n"/>
            <Policies>
                <TimeBasedTriggeringPolicy/>
                <SizeBasedTriggeringPolicy size="100 MB"/>
            </Policies>
        </RollingFile>

        <RollingFile name="RollingFileError" fileName="/Users/tian_dd/logs/spring-boot/error.log"
                     filePattern="/Users/tian_dd/logs/spring-boot/$${date:yyyy-MM}/error-%d{yyyy-MM-dd}-%i.log">
            <ThresholdFilter level="ERROR"/>
            <PatternLayout pattern="[%d{yyyy-MM-dd HH:mm:ss:SSS}] [%p] - [Thread:%t] -%l - %m%n"/>
            <Policies>
                <TimeBasedTriggeringPolicy/>
                <SizeBasedTriggeringPolicy size="100 MB"/>
            </Policies>
        </RollingFile>
    </appenders>

    <loggers>

        <logger name="org.springframework" level="INFO">
        </logger>
        <logger name="org.hibernate" level="INFO">
        </logger>

        <root level="all">
            <appender-ref ref="Console"/>
            <appender-ref ref="RollingFileInfo"/>
            <appender-ref ref="RollingFileWarn"/>
            <appender-ref ref="RollingFileError"/>
        </root>

    </loggers>

</configuration>

这样系统就可以记录操作日志了。

三、Spring Boot集成Mybatis（数据库动态切换）&YML&单元测试

添加POM依赖：

<dependency>
	<groupId>org.mybatis.spring.boot</groupId>
	<artifactId>mybatis-spring-boot-starter</artifactId>
	<version>1.1.1</version>
	<exclusions>
		<exclusion>
			<groupId>org.apache.tomcat</groupId>
			<artifactId>tomcat-jdbc</artifactId>
		</exclusion>
	</exclusions>
</dependency>
<dependency>
	<groupId>mysql</groupId>
	<artifactId>mysql-connector-java</artifactId>
</dependency>
yml文件配置：
spring:
  profiles:
    active: dev
#配置监控项
server:
  port: 8082
management:
  port: 9999
  health:
    mail:
      enabled: false
  security:
    enabled: false

info:
  app:
    name: "@project.name@"
    description: "@project.description@"
    version: "@project.version@"

mybatis:
  mapperLocations: classpath:mapper/*.xml

---
# 开发环境配置
spring:
  profiles: dev
aop:
  multiple:
    datasources:
      default:
        type: com.mysql.jdbc.jdbc2.optional.MysqlXADataSource
        driver-class-name: com.mysql.jdbc.Driver
        url: jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=UTF-8
        username: root
        password: root
      slave:
        type: com.mysql.jdbc.jdbc2.optional.MysqlXADataSource
        driver-class-name: com.mysql.jdbc.Driver
        url: jdbc:mysql://localhost:3306/test_slave?useUnicode=true&characterEncoding=UTF-8
        username: root
        password: root

测试环境配置

spring:
  profiles: test
aop:
  multiple:
    datasources:
      default:
        type: com.mysql.jdbc.jdbc2.optional.MysqlXADataSource
        driver-class-name: com.mysql.jdbc.Driver
        url: jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=UTF-8
        username: root
        password: root
      slave:
        type: com.mysql.jdbc.jdbc2.optional.MysqlXADataSource
        driver-class-name: com.mysql.jdbc.Driver
        url: jdbc:mysql://localhost:3306/test_slave?useUnicode=true&characterEncoding=UTF-8
        username: root
        password: root

---

生产环境配置

spring:
  profiles: prod
aop:
  multiple:
    datasources:
      default:
        type: com.mysql.jdbc.jdbc2.optional.MysqlXADataSource
        driver-class-name: com.mysql.jdbc.Driver
        url: jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=UTF-8
        username: root
        password: root
      slave:
        type: com.mysql.jdbc.jdbc2.optional.MysqlXADataSource
        driver-class-name: com.mysql.jdbc.Driver
        url: jdbc:mysql://localhost:3306/test_slave?useUnicode=true&characterEncoding=UTF-8
        username: root
        password: root

PersonDao接口：

@Repository
@Mapper
public interface PersonDao {
    @Select("SELECT id, first_name AS firstName, last_name AS lastName, birth_date AS birthDate, sex, phone_no AS phoneNo"
            + " FROM t_person WHERE id=#{0};")
    Person getPersonById(int id);
    int insertPerson(Person person);
}

PersonDaoMapper.xml文件:

<insert id="insertPerson">
	INSERT INTO t_person(first_name,last_name,birth_date,sex,phone_no,update_dt)
	VALUES(#{firstName},#{lastName},#{birthDate},#{sex},#{phoneNo},NOW())
</insert>

Spring框架提供了AbstractRoutingDataSource类来实现数据库动态路由，具体编码如下。
MultipleDataSource.java

public class MultipleDataSource extends AbstractRoutingDataSource {

    @Override
    protected Object determineCurrentLookupKey() {
        return MultipleDataSourceContextHolder.getDataSourceName();
    }

}

MultipleDataSourceContextHolder.java

private static final ThreadLocal contextHolder = new ThreadLocal(); //每个请求单独一个数据库持有线程
    public static List dataSourceNames = new ArrayList<>(10);

    public static void setDataSourceName(String dataSourceName) {
        contextHolder.set(dataSourceName);
    }

    public static String getDataSourceName() {
        return contextHolder.get();
    }

    public static void resetDataSourceName() {
        contextHolder.remove();
    }

    public static boolean containsDataSource(String dataSourceName) {
        return dataSourceNames.contains(dataSourceName);
    }

MultipleDataSourceConfiguration.java

@Configuration
@ConfigurationProperties(prefix = "aop.multiple") //Spring Boot会自动从yml文件里解析配置
public class MultipleDataSourceConfiguration {
    private Logger logger = LoggerFactory.getLogger(MultipleDataSourceConfiguration.class);
    //数据源配置，从yml文件中加载
    private Map> datasources;
    @Bean
    public DataSource dataSource() {
        Object defaultDataSource = null;
        Map targetDataSources = new HashMap();
        for (String name : datasources.keySet()) {
            try {
                Map config = datasources.get(name);

                AtomikosDataSourceBean datasource = new AtomikosDataSourceBean();
                datasource.setUniqueResourceName(name);
                datasource.setXaDataSourceClassName(config.get("type"));

                Properties properties = new Properties();
                properties.put("URL", config.get("url"));
                properties.put("user", config.get("username"));
                properties.put("password", config.get("password"));
                datasource.setXaProperties(properties);
                if (name.equals("default")) {
                    defaultDataSource = datasource; //默认为主数据库
                } else {
                    targetDataSources.put(name, datasource);
                    MultipleDataSourceContextHolder.dataSourceNames.add(name);
                }
            } catch (Exception e) {
                logger.error("please check datasources config, ex={}", ExceptionUtils.getStackTrace(e));
                System.exit(1);
            }
        }

        MultipleDataSource multipleDataSource = new MultipleDataSource();
        multipleDataSource.setTargetDataSources(targetDataSources);
        multipleDataSource.setDefaultTargetDataSource(defaultDataSource);
        return multipleDataSource;

    }
}

TargetDataSource

@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface TargetDataSource {
    String name();
}

MultipleDataSourceAspect.java

@Aspect
@Component
public class MultipleDataSourceAspect {

    private Logger logger = LoggerFactory.getLogger(MultipleDataSourceAspect.class);

    @Around("@annotation(com.netease.mail.springboot.annotation.TargetDataSource) && @annotation(targetDataSource)")
    public Object processed(ProceedingJoinPoint point, TargetDataSource targetDataSource) throws Throwable {
        try {

            logger.info("method={}, choose={} database", getMethodName(point), targetDataSource.name());

            String dataSourceName = targetDataSource.name();
            if (MultipleDataSourceContextHolder.containsDataSource(dataSourceName)) {
                MultipleDataSourceContextHolder.setDataSourceName(dataSourceName);
            }
            return point.proceed();
        } finally {
            MultipleDataSourceContextHolder.resetDataSourceName();
        }

    }

    private String getMethodName(ProceedingJoinPoint point) throws NoSuchMethodException{
        Signature sig = point.getSignature();
        MethodSignature msig = (MethodSignature) sig;
        Object target = point.getTarget();
        Method currentMethod = target.getClass().getMethod(msig.getName(), msig.getParameterTypes());
        return currentMethod.getName();
    }

通过对数据库操作方法进行注解&AOP拦截实现数据库动态切换。
PersonService.java

@Service
public class PersonService {

    protected final Logger logger = LoggerFactory.getLogger(this.getClass());
    @Autowired
    private PersonDao personDao;

    @Cacheable(value="getPersonById", sync=true)
    @TargetDataSource(name = "slave") //查询请求走Slave
    public Person getPersonById(int id){
	     logger.info("getting data from database, personId={}", id);
             return personDao.getPersonById(id);
	}

    @Transactional //如果不添加注解，则不会被AOP拦截，这时候会默认走主库
    public int insertPerson(Person person){
	    return personDao.insertPerson(person);
    }

}

可以通过单元测试验证数据库结果。

四、Spring Boot集成JTA事物

如上，配置了多个数据源后，如果一个service方法存在多个数据源，使用jdbc事物不能实现整个方法的回滚操作。这时候需要使用另外一个一种事物管理框架JTA事物。它可以跨数据库来保证数据有效性。当然Spring Boot集成它也比较方便。
DataSourceTransactionManager.java

@Configuration
@ComponentScan
@EnableTransactionManagement //自动开启事物管理
public class DataSourceTransactionManager {

    /**
     * 自定义事务
     * MyBatis自动参与到Spring事务管理中，无需额外配置，只要org.mybatis.spring.SqlSessionFactoryBean引用的数据源与DataSourceTransactionManager引用的数据源一致即可，否则事务管理会不起作用。
     * @return
     */
    @Bean(name = "userTransaction")
    public UserTransaction userTransaction() throws Throwable {
        UserTransactionImp userTransactionImp = new UserTransactionImp();
        userTransactionImp.setTransactionTimeout(10000);
        return userTransactionImp;
    }

    @Bean(name="userTransactionManager", destroyMethod = "close", initMethod = "init")
    public UserTransactionManager userTransactionManager() {
        UserTransactionManager userTransactionManager = new UserTransactionManager();
        userTransactionManager.setForceShutdown(false);
        return userTransactionManager;
    }

    @Bean(name = "transactionManager")
    @DependsOn({ "userTransaction", "userTransactionManager" })
    public JtaTransactionManager transactionManager() throws Throwable {
        UserTransaction userTransaction = userTransaction();
        JtaTransactionManager manager = new JtaTransactionManager(userTransaction,userTransactionManager());
        return manager;
    }

}

开发单元测试验证下：
MultiDataBaseService.java

protected final Logger logger = LoggerFactory.getLogger(this.getClass());

    @Autowired
    private PersonService personService;

    @Transactional
    public void handleInMultiDataBase(){

        Person person = new Person();
        person.setBirthDate(new Date());
        person.setFirstName("tian");
        person.setLastName("dd");
        person.setPhoneNo("222");
        person.setSex('F');

        personService.insertPerson(person);

        Person p = personService.getPersonById(1);
        logger.info("handleInMultiDataBase p={}", JSON.toJSONString(p));

        throw new RuntimeException("测试多数据源数据处理异常事物回滚");

    }

PersonServiceTest.java

@RunWith(SpringRunner.class)
@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
public class PersonServiceTest{

    @Autowired
    MultiDataBaseService multiDataBaseService;

    @Test
    public void testInsertPerson(){

        Person person = new Person();
        person.setBirthDate(new Date());
        person.setFirstName("tian");
        person.setLastName("dd");
        person.setPhoneNo("111");
        person.setSex('F');

        personService.insertPerson(person);
    }
}

通过测试方法发现本条记录并没有插入到主数据库中，说明JTA事物配置成功。

五、Spring Boot监控搭建&编译&部署

添加POM

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

Spring Boot会自动监控系统属性。当然我们也可以自定义一些监控项目。
HealthCheck.java

@Component
public class HealthCheck implements HealthIndicator{

    @Override
    public Health health() {
        //自定义监控项目，实际情况扩充...
        return Health.up().withDetail("health_check", true).build();
    }
}

编译&部署使用如下命令即可：

mvn clean package -Dskiptests
java -jar target/spring-boot.jar --spring.profiles.active=test
#根据系统环境有dev/test/prod

服务启动成功后，就可以直接访问接口了。如Controller层代码如下：
PersonController.java

@RestController
@EnableAutoConfiguration
public class PersonController {

    @Autowired
    private PersonService personService;
   
    @RequestMapping("/person/getPersonById")
    @ResponseBody
    public JsonResult getPersonById(@RequestParam("id") Integer id){
        return new JsonResult(personService.getPersonById(id));
    }
}

服务配置如下：

#配置监控项
server:
  port: 8082
management:
  port: 9999
  health:
    mail:
      enabled: false
  security:
    enabled: false

info:
  app:
    name: "@project.name@"
    description: "@project.description@"
    version: "@project.version@"

curl ‘http://localhost:8082/person/getPersonById?id=11’

{
  code: "200",
  message: "成功",
  data: {
    id: 11,
    firstName: "tian",
    lastName: "dd_slave",
    birthDate: 1510243200000,
    sex: "F",
    phoneNo: "111"
        }
}

curl ‘http://localhost:9999/health’

{
  status: "UP",
  healthCheck: {
  status: "UP",
  health_check: true
},
diskSpace: {
  status: "UP",
  total: 120108089344,
  free: 56391913472,
  threshold: 10485760
},
  db: {
   status: "UNKNOWN" 
  }
}

可以看到系统自定义的监控检查项也返回了。当然Spring Boot健康检查项还有很多API接口，如：info，beans，error等

Spring Boot集成Spring Boot Admin

一、创建服务端

新建立Spring Boot工程，添加如下POM：

<dependency>
	<groupId>de.codecentric</groupId>
	<artifactId>spring-boot-admin-server</artifactId>
	<version>1.5.2</version>
</dependency>
<dependency>
	<groupId>de.codecentric</groupId>
	<artifactId>spring-boot-admin-server-ui</artifactId>
	<version>1.5.2</version>
</dependency>

配置文件：

spring:  
  application:  
    name: spring-boot-admin
  boot:  
    admin:  
      context-path: /sba    # 配置访问路径为：http://localhost:8888/spring-boot-admin/sba
      notify:
        mail:
          to: example@example.com
  mail:
    host: smtp.example.com

server:  
  port: 8888
  context-path: /spring-boot-admin/ #统一为访问的url加上一个前缀

启动类：

@SpringBootApplication
@EnableScheduling
@EnableAdminServer //一定要加上
public class SpringBootAdminApplication {
	public static void main(String[] args) {
		SpringApplication.run(SpringBootAdminApplication.class, args);
	}
}

二、配置客户端

添加POM：

<dependency>  
    <groupId>de.codecentric</groupId>  
    <artifactId>spring-boot-admin-starter-client</artifactId>  
    <version>1.5.2</version>  
</dependency>

配置：

spring:
  profiles:
    active: dev
  boot:
    admin:
      client:
        prefer-ip: true
      url: http://localhost:8888/spring-boot-admin # 向服务端注册的地址

先后启动服务端和客户端后，访问http://localhost:8888/spring-boot-admin/sba链接可查看到被监控的Spring Boot微服务。
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
可以通过这个平台监控系统基本属性&方法调用次数，执行时长&日志&请求Trace等等。当然也可以配置发送邮件模块、集群配置等。

参考资料

http://projects.spring.io/spring-boot
http://codecentric.github.io/spring-boot-admin/1.5.2/#register-clients-via-spring-boot-admin

cr.田躲躲

看到这里的小伙伴，如果你喜欢这篇文章的话，别忘了转发、收藏、留言互动！
如果你想知道更多大厂同学亲授的干货，可以私信我！
还有新整理的海量资料，包含面经分享、模拟试题、视频干货……
在这里插入图片描述

Spring Boot集成Elasticsearch 8.12.2客户端
专注于计算机研发知识和资讯分享
03-29 905
Java REST 客户端已被弃用，取而代之的是 Java API client 客户端，ES 8.x 新版本中，Type 概念被弃用，所以新版 JavaAPI 也相应做出了改变，支持lambda，使用更加简便。ElasticSearch 5.0以后，string类型有重大变更，移除了string类型，string字段被拆分成两种新的数据类型: text用于全文搜索的，而keyword用于关键词搜索。如果按照年进行索引存储，判断查询年份，如果没有对应的索引，则提示查询年份超出范围。
Spring Boot 中文参考指南
分享技术干货和灵感、推荐新书和好玩的项目、分享Java面试题
02-08 9340
虽然Spring Boot 3.x第一个GA版本出来了，但一段时间内市面上依然还会以2.X版本为主，而2.7.8 是最后一个2.x的GA版本
Spring中大事务拆分方案
weixin_39172079的博客
06-01 2340
spring中大事务导致数据库连接不足，死锁的问题 通过编程式事务将事件完成方法和激活方法拆分为单独的事务，每个事件只关注当前事件的操作，后续操作异常时由定时任务进行补偿。
springboot拆分模块分享
itchenguanxi的博客
11-06 554
最近公司有个项目，app端和小程序端，准备重构一下框架。因为业务不大，没考虑微服务，只做了一个模块拆分。总共分成4个模块（app接口、小程序接口、core工程、common工程） 总结一下遇到的问题 拆分模块以后的mybatis配置，mapper和mapper.xml都在core模块，配置在接口模块，需要修改application.java的配置。要把扫描mapper的包修改到core模块下...
Springboot项目工程拆分实现（几乎）不停机更新，拆分方案，maven打包，启动执行总结。
apple1542的博客
10-19 341
Springboot工程拆分，目的：业务更新时，只更新相关业务jar包（子工程），实现不停机维护本次简单描述下，整体思路，若遇到类似需求，且用此方案，后续遇到问题可联系。
Springboot搭建多模块项目，拆分应用
热门推荐
一生只深爱一次
10-14 4万+
工具： idea 首先，我们要搭建的一个项目有以下几个模块 demo-apply  &amp;amp;amp;nbsp;应用模块 demo-common 公用工具类 demo-static  &amp;amp;amp;nbsp;&amp;amp;amp;nbsp;静态资源 好，既然知道了我们想要做的事情，那么对于这些模块，我们需要统一的parent项目，统一管理他们 下面一路next，直接默认就行，关于导入其他依赖包，我们手动导入，最后项目结构如下： 因...
springboot 多模块 -- 将web拆分出去 - 流动计算架构
weixin_30361753的博客
01-09 407
前言: 　　之前将各层都拆分出去, 作为一个独立的可替换的子模块. 感觉比以前确实是灵活了一些. 　　不管是电商项目, 还是现在公司做的项目, 其中, 有很多的业务逻辑, 都是一样的, 但是由于不在一个系统中, 大家需要进行重复的工作. 有的拷贝还好, 但是有的, 没法直接拷贝. 相当的蛋疼. 能不能, 将业务逻辑独立出去, 供所有的展示层调用呢? 　　是不是可以使用前一篇介绍的 dubb...
21天掌握Java Web —— 第一天：Spring Boot入门
最新发布
weixin_38492276的博客
11-27 1209
通过今天的学习，我们不仅掌握了Spring Boot和Java Web的基本概念，还通过实际应用例子展示了如何使用这些技术进行Web开发。我们深入了解了Spring Boot的常用配置选项和优势，以及如何通过配置数据库连接和编写查询语句来实现数据持久化。更重要的是，我们认识到了Spring Boot和Java Web在开发高效、可扩展和可维护Web应用程序中的重要性。在未来的学习中，我们将继续深入探索Spring Boot和Java Web的更多高级特性，不断提升我们的开发技能和水平。
Spring Boot 系统学习第六天：面向切面概念和实践
geminigoth的博客
06-18 1933
在软件开发领域，基于面向对象编程(OOP)的思想和实践，应用程序被划分为多个类和模块。通过引入接口来实现松散耦合的设计，而封装和继承使得我们可以隐藏对象数据并扩展功能。但反过来讲，随着系统的演进，OOP的这些特点也增加了系统的复杂性，为了解决这个问题，我们开始遵循将应用程序划分为不同逻辑层和模块的设计原则，常见的如Web服务层、业务服务层和数据访问层。但是，即使将功能划分为不同的层，所有层中也可能需要某些通用的功能，例如安全性、日志记录、缓存和性能监视。这些功能被称为横切关注点。
Java中的Spring Boot微服务架构设计
技术研究中心
07-04 440
微服务架构是一种以服务为中心的架构风格，它将一个大型应用程序拆分为一组更小、更独立的服务，每个服务都有自己的业务逻辑、数据库和通信机制。Spring Boot是一个基于Spring框架的开发框架，专注于简化Spring应用程序的开发和部署。为了实现微服务的独立部署和弹性扩展，通常将每个微服务打包为Docker容器，并通过容器编排工具如Kubernetes进行管理和部署。通过本文的学习，相信你已经对如何在Java中设计和实现Spring Boot微服务架构有了更深入的理解和认识。
Spring Boot神操作-多个数据源Service层封装
cxu123321的博客
07-07 302
Spring Boot神操作-多个数据源Service层封装 程序员小乐 来自：@pdai| 责编：乐乐 链接：pdai.tech/md/spring/springboot-data-multi.html 程序员小乐(ID:study_tech)第 920次推文 图源：百度 往日回顾：Git从入门到放不下 正文 mysql, es, mongodb 三个数据源用配置文件方式连接，JPA只是正对dao做了封装，本文主要介绍如何对service层进行封装。 Spring...
解决Mail health check failed
杂货铺的小掌柜
04-21 9249
这是个自动注入配置类，那就想了，关掉这个自动注入不就完事了吗，那怎么关掉这个自动注入呢，观察一下，发现了。看这个注解上面的注释，是不是很清楚了，关键是。先看下报错信息，不粘那么多，关键部分如下。很自然就想到看下这个类在哪里用到了，按住。重新启动项目，发现报错信息没了。键的同时点击这类的名称，如下。通过日志可以看出，报错的是。那就点开这个类看一眼，如下。，于是点进去看下，如下。于是，试着配置一下咯。
SpringBoot - 优雅的处理【长事务】
小工匠
03-04 4万+
文章目录PreWhatHow方法一 编程式事务使用@Transactional 又能避免产生长事务方法一方法二 Pre SpringBoot - 实践阿里巴巴【Manager 层_通用业务处理层】 在Spring体系中，在方法上加上注解@Transactional，Spring自动帮我们进行事务的开启、提交、回滚操作，真的是太方便了，以至于不分青红皂白，啥都搞上… What 运行时间比较长，长时间未提交的事务，都可以称之为长事务 长事务引发的常见危害有： 数据库连接池被占满，应用无法获取连接资源
springboot 将大事务拆分为小事务
weixin_42710740的博客
12-15 3665
我们之前做事务管理都是添加@Transactional，但是这个注解只能加在类和方法上，对于方法比较大，但是只有其中部分代码我们需要做事务管理时可以使用。transactionManager。 @Autowired private TransactionTemplate transactionTemplate; @Override public ChannelAddResponse add(ChannelAddRequest channelAddRequest) {
SpringBoot项目拆分 （spring多项目包扫描、依赖注入、jar包引入、数据库操作、项目启动、接口访问）
virtual_users的博客
06-19 4209
SpringBoot项目拆分（按模块拆分） 在了解SpringBoot项目拆分之前首先我们需要了解微服务架构 什么是微服务？ 单个轻量级服务一般为一个单独微服务，微服务讲究的是 专注某个功能的实现，比如登录系统只专注于用户登录方面功能的实现，讲究的是职责单一，开箱即用，可以独立运行。微服务架构系统是一个分布式的系统，按照业务进行划分服务单元模块，解决单个系统的不足，满足越来越复杂的业务需求。 马丁福勒（Martin Fowler）：就目前而言，对于微服务业界并没有一个统一的、标准的定义。但通常而言，微服务
通过Springboot拆分服务构建微服务集
weixin_34293141的博客
09-03 1072
  上个月(16/07)把一个大而全的应用拆分成一个个小的应用。  应用背景： 1.基于Spring Boot开发 2.依赖ActiveMQ，Kafka,Redis,Mongodb,MySQL等开源软件 3.内部服务图片服务器，分布式计算平台服务，检索服务,消息推送服务等  拆分原因：  1.（原有的）应用模块之间高度耦合，各个模块都担当了牵一发而动全身的“角色”  2.应用的配置信息分布到依赖个...
数据库事务，Spring事务
for__future_的博客
06-13 1141
事务
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值