spring1.x实现读写分离

最新推荐文章于 2022-01-18 09:32:00 发布
最新推荐文章于 2022-01-18 09:32:00 发布
阅读量131 收藏
点赞数
文章标签： java spring
原文链接：https://www.jb51.net/article/106555.htm
版权

转载文章：https://www.jb51.net/article/106555.htm
如有侵权立即删除
本文实现案例场景：
某系统除了需要从自己的主要数据库上读取和管理数据外，还有一部分业务涉及到其他多个数据库，要求可以在任何方法上可以灵活指定具体要操作的数据库。

为了在开发中以最简单的方法使用，本文基于注解和AOP的方法实现，在spring boot框架的项目中，添加本文实现的代码类后，只需要配置好数据源就可以直接通过注解使用，简单方便。

一配置二使用

  1. 启动类注册动态数据源

  2. 配置文件中配置多个数据源

  3. 在需要的方法上使用注解指定数据源

1、在启动类添加 @Import({DynamicDataSourceRegister.class, MProxyTransactionManagementConfiguration.class})

1
2
3
4
5
6
@SpringBootApplication
@Import({DynamicDataSourceRegister.class}) // 注册动态多数据源
public class SpringBootSampleApplication {

// 省略其他代码
}
2、配置文件配置内容为： （不包括项目中的其他配置，这里只是数据源相关的）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

主数据源，默认的

spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/test
spring.datasource.username=root
spring.datasource.password=123456

更多数据源

custom.datasource.names=ds1,ds2
custom.datasource.ds1.driver-class-name=com.mysql.jdbc.Driver
custom.datasource.ds1.url=jdbc:mysql://localhost:3306/test1
custom.datasource.ds1.username=root
custom.datasource.ds1.password=123456

custom.datasource.ds2.driver-class-name=com.mysql.jdbc.Driver
custom.datasource.ds2.url=jdbc:mysql://localhost:3306/test2
custom.datasource.ds2.username=root
custom.datasource.ds2.password=123456
3、使用方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
package org.springboot.sample.service;

import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.List;

import org.springboot.sample.datasource.TargetDataSource;
import org.springboot.sample.entity.Student;
import org.springboot.sample.mapper.StudentMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;
import org.springframework.stereotype.Service;

/**

  • Student Service
  • @author 单红宇(365384722)
  • @myblog http://blog.csdn.net/catoop/
  • @create 2016年1月12日
    */
    @Service
    public class StudentService {

@Autowired
private JdbcTemplate jdbcTemplate;

// MyBatis的Mapper方法定义接口
@Autowired
private StudentMapper studentMapper;

@TargetDataSource(name=“ds2”)
public List likeName(String name){
return studentMapper.likeName(name);
}

public List likeNameByDefaultDataSource(String name){
return studentMapper.likeName(name);
}

/**

  • 不指定数据源使用默认数据源

  • @return

  • @author SHANHY

  • @create 2016年1月24日
    */
    public List getList(){
    String sql = “SELECT ID,NAME,SCORE_SUM,SCORE_AVG, AGE FROM STUDENT”;
    return (List) jdbcTemplate.query(sql, new RowMapper(){

    @Override
    public Student mapRow(ResultSet rs, int rowNum) throws SQLException {
    Student stu = new Student();
    stu.setId(rs.getInt(“ID”));
    stu.setAge(rs.getInt(“AGE”));
    stu.setName(rs.getString(“NAME”));
    stu.setSumScore(rs.getString(“SCORE_SUM”));
    stu.setAvgScore(rs.getString(“SCORE_AVG”));
    return stu;
    }

});

}

/**

  • 指定数据源

  • @return

  • @author SHANHY

  • @create 2016年1月24日
    */
    @TargetDataSource(name=“ds1”)
    public List getListByDs1(){
    String sql = “SELECT ID,NAME,SCORE_SUM,SCORE_AVG, AGE FROM STUDENT”;
    return (List) jdbcTemplate.query(sql, new RowMapper(){

    @Override
    public Student mapRow(ResultSet rs, int rowNum) throws SQLException {
    Student stu = new Student();
    stu.setId(rs.getInt(“ID”));
    stu.setAge(rs.getInt(“AGE”));
    stu.setName(rs.getString(“NAME”));
    stu.setSumScore(rs.getString(“SCORE_SUM”));
    stu.setAvgScore(rs.getString(“SCORE_AVG”));
    return stu;
    }

});

}

/**

  • 指定数据源

  • @return

  • @author SHANHY

  • @create 2016年1月24日
    */
    @TargetDataSource(name=“ds2”)
    public List getListByDs2(){
    String sql = “SELECT ID,NAME,SCORE_SUM,SCORE_AVG, AGE FROM STUDENT”;
    return (List) jdbcTemplate.query(sql, new RowMapper(){

    @Override
    public Student mapRow(ResultSet rs, int rowNum) throws SQLException {
    Student stu = new Student();
    stu.setId(rs.getInt(“ID”));
    stu.setAge(rs.getInt(“AGE”));
    stu.setName(rs.getString(“NAME”));
    stu.setSumScore(rs.getString(“SCORE_SUM”));
    stu.setAvgScore(rs.getString(“SCORE_AVG”));
    return stu;
    }

});

}
}
要注意的是，在使用MyBatis时，注解@TargetDataSource 不能直接在接口类Mapper上使用。
按上面的代码中StudentMapper为接口，代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
package org.springboot.sample.mapper;

import java.util.List;

import org.springboot.sample.entity.Student;

/**

  • StudentMapper，映射SQL语句的接口，无逻辑实现
  • @author 单红宇(365384722)
  • @myblog http://blog.csdn.net/catoop/
  • @create 2016年1月20日
    */
    public interface StudentMapper {

// 注解 @TargetDataSource 不可以在这里使用
List likeName(String name);

Student getById(int id);

String getNameById(int id);

}
请将下面几个类放到Spring Boot项目中。
DynamicDataSource.Java
DynamicDataSourceAspect.java
DynamicDataSourceContextHolder.java
DynamicDataSourceRegister.java
TargetDataSource.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
package org.springboot.sample.datasource;

import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;

/**

  • 动态数据源
  • @author 单红宇(365384722)
  • @create 2016年1月22日
    */
    public class DynamicDataSource extends AbstractRoutingDataSource {

@Override
protected Object determineCurrentLookupKey() {
return DynamicDataSourceContextHolder.getDataSourceType();
}

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
package org.springboot.sample.datasource;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;

/**

  • 切换数据源Advice
  • @author 单红宇(365384722)
  • @create 2016年1月23日
    */
    @Aspect
    @Order(-1)// 保证该AOP在@Transactional之前执行
    @Component
    public class DynamicDataSourceAspect {

private static final Logger logger = LoggerFactory.getLogger(DynamicDataSourceAspect.class);

@Before("@annotation(ds)")
public void changeDataSource(JoinPoint point, TargetDataSource ds) throws Throwable {
String dsId = ds.name();
if (!DynamicDataSourceContextHolder.containsDataSource(dsId)) {
logger.error(“数据源[{}]不存在，使用默认数据源 > {}”, ds.name(), point.getSignature());
} else {
logger.debug(“Use DataSource : {} > {}”, ds.name(), point.getSignature());
DynamicDataSourceContextHolder.setDataSourceType(ds.name());
}
}

@After("@annotation(ds)")
public void restoreDataSource(JoinPoint point, TargetDataSource ds) {
logger.debug(“Revert DataSource : {} > {}”, ds.name(), point.getSignature());
DynamicDataSourceContextHolder.clearDataSourceType();
}

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
package org.springboot.sample.datasource;

import java.util.ArrayList;
import java.util.List;

public class DynamicDataSourceContextHolder {

private static final ThreadLocal contextHolder = new ThreadLocal();
public static List dataSourceIds = new ArrayList<>();

public static void setDataSourceType(String dataSourceType) {
contextHolder.set(dataSourceType);
}

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

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

/**

  • 判断指定DataSrouce当前是否存在
  • @param dataSourceId
  • @return
  • @author SHANHY
  • @create 2016年1月24日
    */
    public static boolean containsDataSource(String dataSourceId){
    return dataSourceIds.contains(dataSourceId);
    }
    }
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
    163
    164
    165
    166
    167
    168
    169
    170
    171
    172
    173
    174
    175
    176
    177
    178
    179
    180
    181
    182
    183
    184
    185
    186
    package org.springboot.sample.datasource;

import java.util.HashMap;
import java.util.Map;

import javax.sql.DataSource;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.MutablePropertyValues;
import org.springframework.beans.PropertyValues;
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.beans.factory.support.GenericBeanDefinition;
import org.springframework.boot.autoconfigure.jdbc.DataSourceBuilder;
import org.springframework.boot.bind.RelaxedDataBinder;
import org.springframework.boot.bind.RelaxedPropertyResolver;
import org.springframework.context.EnvironmentAware;
import org.springframework.context.annotation.ImportBeanDefinitionRegistrar;
import org.springframework.core.convert.ConversionService;
import org.springframework.core.convert.support.DefaultConversionService;
import org.springframework.core.env.Environment;
import org.springframework.core.type.AnnotationMetadata;

/**

  • 动态数据源注册
  • 启动动态数据源请在启动类中（如SpringBootSampleApplication）
  • 添加 @Import(DynamicDataSourceRegister.class)
  • @author 单红宇(365384722)
  • @create 2016年1月24日
    */
    public class DynamicDataSourceRegister
    implements ImportBeanDefinitionRegistrar, EnvironmentAware {

private static final Logger logger = LoggerFactory.getLogger(DynamicDataSourceRegister.class);

private ConversionService conversionService = new DefaultConversionService();
private PropertyValues dataSourcePropertyValues;

// 如配置文件中未指定数据源类型，使用该默认值
private static final Object DATASOURCE_TYPE_DEFAULT = “org.apache.tomcat.jdbc.pool.DataSource”;
// private static final Object DATASOURCE_TYPE_DEFAULT =
// “com.zaxxer.hikari.HikariDataSource”;

// 数据源
private DataSource defaultDataSource;
private Map<String, DataSource> customDataSources = new HashMap<>();

@Override
public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
Map<Object, Object> targetDataSources = new HashMap<Object, Object>();
// 将主数据源添加到更多数据源中
targetDataSources.put(“dataSource”, defaultDataSource);
DynamicDataSourceContextHolder.dataSourceIds.add(“dataSource”);
// 添加更多数据源
targetDataSources.putAll(customDataSources);
for (String key : customDataSources.keySet()) {
DynamicDataSourceContextHolder.dataSourceIds.add(key);
}

// 创建DynamicDataSource
GenericBeanDefinition beanDefinition = new GenericBeanDefinition();
beanDefinition.setBeanClass(DynamicDataSource.class);
beanDefinition.setSynthetic(true);
MutablePropertyValues mpv = beanDefinition.getPropertyValues();
mpv.addPropertyValue("defaultTargetDataSource", defaultDataSource);
mpv.addPropertyValue("targetDataSources", targetDataSources);
registry.registerBeanDefinition("dataSource", beanDefinition);

logger.info("Dynamic DataSource Registry");

}

/**

  • 创建DataSource

  • @param type

  • @param driverClassName

  • @param url

  • @param username

  • @param password

  • @return

  • @author SHANHY

  • @create 2016年1月24日
    */
    @SuppressWarnings(“unchecked”)
    public DataSource buildDataSource(Map<String, Object> dsMap) {
    try {
    Object type = dsMap.get(“type”);
    if (type == null)
    type = DATASOURCE_TYPE_DEFAULT;// 默认DataSource

    Class<? extends DataSource> dataSourceType;
    dataSourceType = (Class<? extends DataSource>) Class.forName((String) type);

    String driverClassName = dsMap.get(“driver-class-name”).toString();
    String url = dsMap.get(“url”).toString();
    String username = dsMap.get(“username”).toString();
    String password = dsMap.get(“password”).toString();

    DataSourceBuilder factory = DataSourceBuilder.create().driverClassName(driverClassName).url(url)
    .username(username).password(password).type(dataSourceType);
    return factory.build();
    } catch (ClassNotFoundException e) {
    e.printStackTrace();
    }
    return null;
    }

/**

  • 加载多数据源配置
    */
    @Override
    public void setEnvironment(Environment env) {
    initDefaultDataSource(env);
    initCustomDataSources(env);
    }

/**

  • 初始化主数据源
  • @author SHANHY
  • @create 2016年1月24日
    */
    private void initDefaultDataSource(Environment env) {
    // 读取主数据源
    RelaxedPropertyResolver propertyResolver = new RelaxedPropertyResolver(env, “spring.datasource.”);
    Map<String, Object> dsMap = new HashMap<>();
    dsMap.put(“type”, propertyResolver.getProperty(“type”));
    dsMap.put(“driver-class-name”, propertyResolver.getProperty(“driver-class-name”));
    dsMap.put(“url”, propertyResolver.getProperty(“url”));
    dsMap.put(“username”, propertyResolver.getProperty(“username”));
    dsMap.put(“password”, propertyResolver.getProperty(“password”));
defaultDataSource = buildDataSource(dsMap);

dataBinder(defaultDataSource, env);

}

/**

  • 为DataSource绑定更多数据
  • @param dataSource
  • @param env
  • @author SHANHY
  • @create 2016年1月25日
    */
    private void dataBinder(DataSource dataSource, Environment env){
    RelaxedDataBinder dataBinder = new RelaxedDataBinder(dataSource);
    //dataBinder.setValidator(new LocalValidatorFactory().run(this.applicationContext));
    dataBinder.setConversionService(conversionService);
    dataBinder.setIgnoreNestedProperties(false);//false
    dataBinder.setIgnoreInvalidFields(false);//false
    dataBinder.setIgnoreUnknownFields(true);//true
    if(dataSourcePropertyValues == null){
    Map<String, Object> rpr = new RelaxedPropertyResolver(env, “spring.datasource”).getSubProperties(".");
    Map<String, Object> values = new HashMap<>(rpr);
    // 排除已经设置的属性
    values.remove(“type”);
    values.remove(“driver-class-name”);
    values.remove(“url”);
    values.remove(“username”);
    values.remove(“password”);
    dataSourcePropertyValues = new MutablePropertyValues(values);
    }
    dataBinder.bind(dataSourcePropertyValues);
    }

/**

  • 初始化更多数据源
  • @author SHANHY
  • @create 2016年1月24日
    */
    private void initCustomDataSources(Environment env) {
    // 读取配置文件获取更多数据源，也可以通过defaultDataSource读取数据库获取更多数据源
    RelaxedPropertyResolver propertyResolver = new RelaxedPropertyResolver(env, “custom.datasource.”);
    String dsPrefixs = propertyResolver.getProperty(“names”);
    for (String dsPrefix : dsPrefixs.split(",")) {// 多个数据源
    Map<String, Object> dsMap = propertyResolver.getSubProperties(dsPrefix + “.”);
    DataSource ds = buildDataSource(dsMap);
    customDataSources.put(dsPrefix, ds);
    dataBinder(ds, env);
    }
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
package org.springboot.sample.datasource;

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**

  • 在方法上使用，用于指定使用哪个数据源
  • @author 单红宇(365384722)
  • @create 2016年1月23日
    */
    @Target({ ElementType.METHOD, ElementType.TYPE })
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    public @interface TargetDataSource {
    String name();
    }
    本文代码博主是经过测试后没有问题才发出来共享给大家的。对于连接池参数配置会应用到所有数据源上。
    比如配置一个：

1
spring.datasource.maximum-pool-size=80
那么我们所有的数据源都会自动应用上。

补充：
如果你使用的是SpringMVC，并集成了Shiro，一般按网上的配置你可能是：

1
2
3
4
5
6
7


那么你请不要这样做，请按下面方法配置：

1
2
3
4
5
6
7
8

<aop:config proxy-target-class=“true”/>

小飞机爱旅游
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Spring学习1-概述
jeikerxiao
11-30 384
1.Spring发展1.1第一阶段：xml配置在Spring 1.x的时候，使用Spring开发都是xml配置的Bean。随着项目的扩大，xml被分到不同的配置文件中，这时候开发时需要频繁地在开发类和xml配置文件之间切换。1.2第二阶段：注解配置在Spring 2.x的时候，随着JDK 1.5带来的注解支持，Spring也提供了声明Bean的注解，大大减少了xml的配置量。这时就有一个争论：是注解
Spring1.x 和Spring2.x 版本上使用有什么区别
02-22
详细介绍了Spring1.x 和Spring2.x 版本上使用有什么区别
Spring 1.x 到2.x，再到 3.x，最后SpringBoot
专注于后端开发，时常接触大数据 、人工智能等
07-22 1410
一，Spring的发展 1，Spring1.x时代 在Spring1.x时代，都是通过xml文件配置bean，随着项目的不断扩大，需要将xml配置分放到不同的配置文件中，需要频繁的在java类和xml配置文件中切换。 2，Spring2.x时代 随着JDK1.5带来的注解支持，Spring2.x可以使用注解对Bean进行申明和注入，大大的减少了xml配置文件，同时也大大简化了项目的开发...
Spring1.1.x + Hibernate2.x升级到Spring1.2 + hibernate3.x
Alex Qiu Liang Jun的个人空间
06-02 1519
这几天做了一下从Spring1.1.x + Hibernate2.x升级到Spring1.2 + hibernate3.x，具体步骤如下：1. 修改project.xml改变dependency，spring使用1.2,hibernate使用3.0.5, 另外加入一下的依赖：hessian-2.1.12 、 pache Axis 1.2、c3p0-0.8.5.2、ehcache-1.1.jar和a
SpringFramework注解的发展与演变，从Spring 1.x到Spring 5.x
毛毛的专栏
06-26 816
文章目录一、前言二、Spring1.x三、Spring2.x四、Spring3.x(无配置化bean装配)4.1 自己的bean去xml化4.1.1 去xml化解决IOC4.1.2 去xml化解决依赖注入4.1.3 @Import注解(扩大扫描范围)4.1.4 @Scope注解4.2 第三方bean去xml化五、Spring4.x(注解方式的完善)5.1 @Conditional条件注解六、Spring5.x(注解性能上的优化)七、小结 一、前言 SpringFramework注解的发展过程就是一个不断消除
SpringBoot2.x 继承 AbstractRoutingDataSource 动态数据源切换实现 JPA读写分离
12-24
SpringBoot2.x 继承 AbstractRoutingDataSource 动态数据源切换实现 JPA读写分离。 使用MyCat代理MySQL8数据库，添加root账户(读写)和user账户（只读）模拟读写简单分离。
动态数据源演示：基于事务的读写分离
01-30
应用层读写分离的改进背景数据库读写分离是先进的Web架构不可替代的一环，其主要提升在于：主从职能单一，主写从读，可以极大程度地减轻X锁和S锁的竞争，并且可以进行针对性调优请求分流，减少主库压力当读成为DB...
x-jdbc:简单的基于jdbc规范的读写分离框架
04-30
读库的高可用(一期未实现).x-jdbc的想法:当应用想使用读写分离功能时,可以很方便的接入,因为x-jdbc就是一个jar包,并扩展了Spring的自定义标签方便应用通过xjdbc:cluter,xjdbc:rwds来定义数据源,并将x-jdbc的数据源...
JEHC-CLOUD基于Spring Cloud 2.X版本，采用前后端分离，集成了多方向平台如互联网物联网传统软件医疗医疗方向
最新发布
01-11
采用技术为： spring，springBoot，Mybatis，Mysql，Redis，Activiti，自研BPM可视化设计器兼容IE，火狐，谷歌，360等浏览器，集成系统性能监控模块，tk压缩，VUE，数据库读写分离，MQ消息中间件等技术
dynamic-datasource-spring-boot-starter：springboot的动态数据源多数据源动态数据源主从分离读写分离分布式事务https：dynamic-datasource.com
01-30
文件| 文献资料|特性支持数据源分组，适用于多种场景纯粹的多库读写分离一主多从混合模式。支持数据库敏感配置信息加密ENC（）。支持每个数据库独立初始化表结构schema和数据库数据库。支持自定义注解，需继承DS...
Spring Boot 实现读写分离，还有谁不会
mxy2404830的博客
12-23 820
第一步：配置多数据源 Spring Boot 基础就不介绍了，推荐下这个实战教程： github.com/javastacks/… 首先，我们在 SpringBoot 中配置两个数据源，其中第二个数据源是ro-datasource： spring: datasource: jdbc-url: jdbc:mysql://localhost/test username: rw password: rw_password driver-class-name: com..
spring1.x 的acegi 配置文件
梦想与激情同在
08-20 107
[code="java"] CONVERT_URL_TO_LOWERCASE_BEFORE_COMPARISON PATTERN_TYPE_APACHE_ANT /**=httpSessionContextIntegrationFilter,authenticationProcessingFilter,logoutFil...
学习笔记（2）基本配置以及高性能高可用数据库设计
weixin_46104393的博客
12-02 485
学习笔记（2）基本配置以及高性能高可用数据库设计 基本配置 微服务设计 gmall-api：抽取所有的bean、模型类、异常、通用类等 gmall-common：抽取工具类，通用类等 gmall_pms：商品管理系统 gmall_ums：用户管理系统 gmall_sms：营销管理系统 gmall_admin_web: 后台管理系统对接前端的web项目 gmall_api: 不包含mapper，impl，mapper应该是每个具体实现里的，impl应该是服务类的真正实现。api保留了接口，javabean。
Struts1.X与Spring集成——第一种方案
葵歌小妖
07-23 4518
spring+struts(第一种方案) 集成原理：在Action中取得BeanFactory,通过BeanFactory取得业务逻辑对象   一,新建一个项目Spring_Struts_01，项目结构如下 国 UserManager 」 ava > 国 UserMangerImpl 」 ava 实 现 combpowernode usermgr web.actlons > 1 刂 Lo
1+X 云计算运维与开发（中级）案例实战——构建读写分离的数据库集群
Destiny_0991
05-05 4275
传送门 教育部：职业教育将启动“1+X”证书制度改革 职业教育改革1+X证书制度试点启动 1+X成绩/证书查询入口 文章目录1. 案例目标2. 案例分析2.1 规划节点2.2 基础准备3. 案例实施3.1 基础环境配置3.2 部署MariaDB主从数据库集群服务3.3 部署Mycat读写分离中间件服务 1. 案例目标 了解mycat提供的读写分离功能 了解mysql数据库的主从架构 构建以m...
spring 0.9/1.x/2.x老版本源码下载地址
xingshen100的专栏
08-10 913
https://sourceforge.net/projects/springframework/files/  
SpringBoot 1.x和2.x区别记录
热门推荐
MRGCODING
03-12 1万+
新版本代码无需任何变更，只需更新部分配置文件，改动原因是 配置已经不存在或者改名 类已经不存在改名 开发中需要变更的部分配置如下： 1. SpringBoot 2基于Spring5和JDK8，而Spring 1x则用的是低版本 2. MVC部分，WebMvcConfiguer,由抽象类改为接口，这是因为JDK8对接口有新的支持形式；视图渲染Freemaker视图解析器也有改动，默认情况下，...
怎样使用Spring的配置文件？带大家一起玩转Spring配置文件
知识记录
01-18 545
整理了自己的学习笔记，包括Spring程序的快速使用、Bean标签的使用和其属性的具体使用，每个属性都用代码来解释，运行结果和案例写的都很明白，喜欢大家喜欢。
springcloud如何实现数据库读写分离
04-03
Spring Cloud可以通过使用动态数据源实现数据库读写分离，具体步骤如下： 1. 引入相关依赖 在Spring Boot项目的pom.xml文件中引入以下依赖： ``` <!-- MyBatis --> <groupId>org.mybatis.spring.boot ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值