RocketMQ高并发项目——Dubbo 整合以及接口测试

港控/mmm° 2022-02-04 10:15 137阅读 0赞

整个项目的一个流程如下图所示：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NTgyNjA0_size_16_color_FFFFFF_t_70][]

首先我们需要创建一个Maven父工程RocketParent，然后再创建三个子模块order（服务调用者），store（服务提供者），storeapi（服务提供者api接口）

![20190507210924168.png][]

我们来看下order的pom文件，application.properties，com.yy.orider.config.database包下的dubbo配置文件

<?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">
        <parent>
            <artifactId>RocketParent</artifactId>
            <groupId>com.yy</groupId>
            <version>1.0-SNAPSHOT</version>
        </parent>
        <modelVersion>4.0.0</modelVersion>
    
        <artifactId>order</artifactId>
    
        <dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-actuator</artifactId>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-jdbc</artifactId>
            </dependency>
            <dependency>
                <groupId>org.mybatis.spring.boot</groupId>
                <artifactId>mybatis-spring-boot-starter</artifactId>
                <version>1.1.1</version>
            </dependency>
            <dependency>
                <groupId>tk.mybatis</groupId>
                <artifactId>mapper-spring-boot-starter</artifactId>
                <version>1.1.0</version>
            </dependency>
            <dependency>
                <groupId>log4j</groupId>
                <artifactId>log4j</artifactId>
                <version>${log4j.version}</version>
            </dependency>
            <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>druid</artifactId>
                <version>${druid.version}</version>
            </dependency>
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
            </dependency>
            
    
    
            <dependency>
                <groupId>com.alibaba.boot</groupId>
                <artifactId>dubbo-spring-boot-starter</artifactId>
                <version>${dubbo.version}</version>
            </dependency>
            <dependency>
                <groupId>com.alibaba.boot</groupId>
                <artifactId>dubbo-spring-boot-actuator</artifactId>
                <version>${dubbo.version}</version>
            </dependency>
    
            <dependency>
                <groupId>com.yy</groupId>
                <artifactId>store-api</artifactId>
                <version>1.0-SNAPSHOT</version>
            </dependency>
    
        </dependencies>
    
    </project>

server.servlet.context-path=/
    server.port=8001
    
    spring.http.encoding.charset=UTF-8
    spring.jackson.date-format=yyyy-MM-dd HH:mm:ss
    spring.jackson.time-zone=GMT+8
    spring.jackson.default-property-inclusion=NON_NULL
    
    spring.datasource.type=com.alibaba.druid.pool.DruidDataSource
    spring.datasource.url=jdbc:mysql://localhost:3306/rocket?useSSL=false
    spring.datasource.driver-class-name=com.mysql.jdbc.Driver
    spring.datasource.username=root
    spring.datasource.password=root
    
    spring.datasource.initialSize=5
    spring.datasource.minIdle=1
    spring.datasource.maxIdle=10
    spring.datasource.maxActive=100
    spring.datasource.maxWait=60000
    spring.datasource.timeBetweenEvictionRunsMillis=60000
    spring.datasource.minEvictableIdleTimeMillis=300000
    spring.datasource.validationQuery=SELECT 1 FROM DUAL
    spring.datasource.testWhileIdle=true
    spring.datasource.testOnBorrow=false
    spring.datasource.testOnReturn=false
    spring.datasource.poolPreparedStatements=true
    spring.datasource.maxPoolPreparedStatementPerConnectionSize= 20
    spring.datasource.filters=stat,wall,log4j
    spring.datasource.useGlobalDataSourceStat=true
    spring.datasource.connectionProperties=druid.stat.mergeSql=true;druid.stat.slowSqlMillis=5000
    
    
    #mybatis.type-aliases-package=com.yy.order
    #mybatis.mapper-locations=classpath:com/yy/order/mapping/*.xml
    
    logging.level.tk.mybatis=TRACE
    
    
    # Dubbo Config properties
    dubbo.application.id=order
    dubbo.application.name=order
    dubbo.application.qosPort=22211
    dubbo.application.qosEnable=true
    dubbo.scan.basePackages=com.yy.order.*
    dubbo.protocol.id=dubbo
    dubbo.protocol.name=dubbo
    dubbo.protocol.port=12343
    dubbo.registry.id=order-registry
    dubbo.registry.address=zookeeper://172.20.10.13:2181?backup=172.20.10.14:2181,172.20.10.2:2181
    
    # Enables Dubbo All Endpoints
    management.endpoint.dubbo.enabled = true
    management.endpoint.dubbo-shutdown.enabled = true
    management.endpoint.dubbo-configs.enabled = true
    management.endpoint.dubbo-services.enabled = true
    management.endpoint.dubbo-references.enabled = true
    management.endpoint.dubbo-properties.enabled = true
    
    # Dubbo Health
    ## StatusChecker Name defaults (default : "memory", "load" )
    management.health.dubbo.status.defaults = memory
    ## StatusChecker Name extras (default : empty )
    management.health.dubbo.status.extras = load,threadpool

package com.yy.order.config.database;
    
    import com.alibaba.druid.pool.DruidDataSource;
    import com.alibaba.druid.support.http.StatViewServlet;
    import com.alibaba.druid.support.http.WebStatFilter;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.boot.web.servlet.FilterRegistrationBean;
    import org.springframework.boot.web.servlet.ServletRegistrationBean;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.context.support.PropertySourcesPlaceholderConfigurer;
    import org.springframework.jdbc.datasource.DataSourceTransactionManager;
    import org.springframework.transaction.PlatformTransactionManager;
    import org.springframework.transaction.annotation.EnableTransactionManagement;
    
    import javax.sql.DataSource;
    import java.sql.SQLException;
    
    @Configuration
    @EnableTransactionManagement
    public class DruidDataSourceConfig {
    	
    	private static Logger logger = LoggerFactory.getLogger(DruidDataSourceConfig.class);
    	
    	@Autowired
    	private DruidDataSourceSettings druidSettings;
    	
    	public static String DRIVER_CLASSNAME ;
    	
    	@Bean
    	public static PropertySourcesPlaceholderConfigurer propertyConfigure(){
    		return new PropertySourcesPlaceholderConfigurer();
    	}	
    	
        @Bean
        public ServletRegistrationBean druidServlet() {
        	
            ServletRegistrationBean reg = new ServletRegistrationBean();
            reg.setServlet(new StatViewServlet());
    //        reg.setAsyncSupported(true);
            reg.addUrlMappings("/druid/*");
            reg.addInitParameter("allow", "localhost");
            reg.addInitParameter("deny","/deny");
    //        reg.addInitParameter("loginUsername", "bhz");
    //        reg.addInitParameter("loginPassword", "bhz");
            logger.info(" druid console manager init : {} ", reg);
            return reg;
        }
    
        @Bean
        public FilterRegistrationBean filterRegistrationBean() {
            FilterRegistrationBean filterRegistrationBean = new FilterRegistrationBean();
            filterRegistrationBean.setFilter(new WebStatFilter());
            filterRegistrationBean.addUrlPatterns("/*");
            filterRegistrationBean.addInitParameter("exclusions", "*.js,*.gif,*.jpg,*.png,*.css,*.ico, /druid/*");
            logger.info(" druid filter register : {} ", filterRegistrationBean);
            return filterRegistrationBean;
        }
        
    	@Bean
    	public DataSource dataSource() throws SQLException {
    		DruidDataSource ds = new DruidDataSource();
    		ds.setDriverClassName(druidSettings.getDriverClassName());
    		DRIVER_CLASSNAME = druidSettings.getDriverClassName();
    		ds.setUrl(druidSettings.getUrl());
    		ds.setUsername(druidSettings.getUsername());
    		ds.setPassword(druidSettings.getPassword());
    		ds.setInitialSize(druidSettings.getInitialSize());
    		ds.setMinIdle(druidSettings.getMinIdle());
    		ds.setMaxIdle(druidSettings.getMaxIdle());
    		ds.setMaxActive(druidSettings.getMaxActive());
    		ds.setTimeBetweenEvictionRunsMillis(druidSettings.getTimeBetweenEvictionRunsMillis());
    		ds.setMinEvictableIdleTimeMillis(druidSettings.getMinEvictableIdleTimeMillis());
    		ds.setValidationQuery(druidSettings.getValidationQuery());
    		ds.setTestWhileIdle(druidSettings.isTestWhileIdle());
    		ds.setTestOnBorrow(druidSettings.isTestOnBorrow());
    		ds.setTestOnReturn(druidSettings.isTestOnReturn());
    		ds.setPoolPreparedStatements(druidSettings.isPoolPreparedStatements());
    		ds.setMaxPoolPreparedStatementPerConnectionSize(druidSettings.getMaxPoolPreparedStatementPerConnectionSize());
    		ds.setFilters(druidSettings.getFilters());
    		ds.setConnectionProperties(druidSettings.getConnectionProperties());
    		
    		//proxyFilters ===> 有问题
    //		WallFilter wallFilter = new WallFilter();
    //		WallConfig wallConfig = new WallConfig();
    //		wallConfig.setMultiStatementAllow(true);
    //		wallFilter.setConfig(wallConfig);
    //		List<Filter> wallFilterList = new ArrayList<Filter>();
    //		wallFilterList.add(wallFilter);
    //		ds.setProxyFilters(wallFilterList);
    		logger.info(" druid datasource config : {} ", ds);
    		return ds;
    	}
    
    	@Bean
    	public PlatformTransactionManager transactionManager() throws Exception {
    		DataSourceTransactionManager txManager = new DataSourceTransactionManager();
    		txManager.setDataSource(dataSource());
    		return txManager;
    	}
        
    }

package com.yy.order.config.database;
    
    import org.springframework.boot.context.properties.ConfigurationProperties;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.support.PropertySourcesPlaceholderConfigurer;
    import org.springframework.stereotype.Component;
    
    @Component
    @ConfigurationProperties(prefix="spring.datasource") 
    public class DruidDataSourceSettings {
    
    	private String driverClassName;
    	private String url;
    	private String username;
    	private String password;
    	
    	private int initialSize;
    	
    	private int minIdle;
    	
    	private int maxIdle;
    	
    	private int maxActive;
    	
    	private long timeBetweenEvictionRunsMillis;
    	
    	private long minEvictableIdleTimeMillis;
    	
    	private String validationQuery;
    	
    	private boolean testWhileIdle;
    	
    	private boolean testOnBorrow;
    	
    	private boolean testOnReturn;
    	
    	private boolean poolPreparedStatements;
    	
    	private int maxPoolPreparedStatementPerConnectionSize;
    	
    	private String filters;
    	
    	private String connectionProperties;
    	
    	@Bean
    	public static PropertySourcesPlaceholderConfigurer properdtyConfigure(){
    		return new PropertySourcesPlaceholderConfigurer();
    	}
    	
    	public String getDriverClassName() {
    		return driverClassName;
    	}
    	public void setDriverClassName(String driverClassName) {
    		this.driverClassName = driverClassName;
    	}
    	public String getUrl() {
    		return url;
    	}
    	public void setUrl(String url) {
    		this.url = url;
    	}
    	public String getUsername() {
    		return username;
    	}
    	public void setUsername(String username) {
    		this.username = username;
    	}
    	public String getPassword() {
    		return password;
    	}
    	public void setPassword(String password) {
    		this.password = password;
    	}
    	public int getInitialSize() {
    		return initialSize;
    	}
    	public void setInitialSize(int initialSize) {
    		this.initialSize = initialSize;
    	}
    	public int getMinIdle() {
    		return minIdle;
    	}
    	public void setMinIdle(int minIdle) {
    		this.minIdle = minIdle;
    	}
    	public int getMaxIdle() {
    		return maxIdle;
    	}
    	public void setMaxIdle(int maxIdle) {
    		this.maxIdle = maxIdle;
    	}
    	public int getMaxActive() {
    		return maxActive;
    	}
    	public void setMaxActive(int maxActive) {
    		this.maxActive = maxActive;
    	}
    	public long getTimeBetweenEvictionRunsMillis() {
    		return timeBetweenEvictionRunsMillis;
    	}
    	public void setTimeBetweenEvictionRunsMillis(long timeBetweenEvictionRunsMillis) {
    		this.timeBetweenEvictionRunsMillis = timeBetweenEvictionRunsMillis;
    	}
    	public long getMinEvictableIdleTimeMillis() {
    		return minEvictableIdleTimeMillis;
    	}
    	public void setMinEvictableIdleTimeMillis(long minEvictableIdleTimeMillis) {
    		this.minEvictableIdleTimeMillis = minEvictableIdleTimeMillis;
    	}
    	public String getValidationQuery() {
    		return validationQuery;
    	}
    	public void setValidationQuery(String validationQuery) {
    		this.validationQuery = validationQuery;
    	}
    	public boolean isTestWhileIdle() {
    		return testWhileIdle;
    	}
    	public void setTestWhileIdle(boolean testWhileIdle) {
    		this.testWhileIdle = testWhileIdle;
    	}
    	public boolean isTestOnBorrow() {
    		return testOnBorrow;
    	}
    	public void setTestOnBorrow(boolean testOnBorrow) {
    		this.testOnBorrow = testOnBorrow;
    	}
    	public boolean isTestOnReturn() {
    		return testOnReturn;
    	}
    	public void setTestOnReturn(boolean testOnReturn) {
    		this.testOnReturn = testOnReturn;
    	}
    	public boolean isPoolPreparedStatements() {
    		return poolPreparedStatements;
    	}
    	public void setPoolPreparedStatements(boolean poolPreparedStatements) {
    		this.poolPreparedStatements = poolPreparedStatements;
    	}
    	public int getMaxPoolPreparedStatementPerConnectionSize() {
    		return maxPoolPreparedStatementPerConnectionSize;
    	}
    	public void setMaxPoolPreparedStatementPerConnectionSize(
    			int maxPoolPreparedStatementPerConnectionSize) {
    		this.maxPoolPreparedStatementPerConnectionSize = maxPoolPreparedStatementPerConnectionSize;
    	}
    	public String getFilters() {
    		return filters;
    	}
    	public void setFilters(String filters) {
    		this.filters = filters;
    	}
    	public String getConnectionProperties() {
    		return connectionProperties;
    	}
    	public void setConnectionProperties(String connectionProperties) {
    		this.connectionProperties = connectionProperties;
    	}
    	
    }

当我们使用order服务中的下单请求时，会要调用store服务里面的接口，所以我们需要将store服务里面的接口单独提出一个jar，这个单独的jar就不需要继承父工程RocketParent了。store-api接口如下

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NTgyNjA0_size_16_color_FFFFFF_t_70 1][]

然后我们需要在order和store模块的pom文件中引入store-api这个模块

![2019050719504922.png][]

store-api接口写好后我们需要在store服务编写它的实现，我们不应该在store服务的com.yy.store.service.impl来实现这个接口，而是应该另写一个com.yy.store.service.provider包下来实现，这个包下都是对外提供的服务，而service.impl包下则是对内提供的服务（有些服务它既是对内提供，又是对外提供，那我们就需要在两个包下都写上）

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NTgyNjA0_size_16_color_FFFFFF_t_70 2][]

store服务提供者写好了，我们就开始写服务调用者order

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NTgyNjA0_size_16_color_FFFFFF_t_70 3][]

可以看到我们引用的是store-api服务中的接口

最后我们将三个zookeep节点启动，然后在浏览器中测试：

![2019050720512119.png][]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NTgyNjA0_size_16_color_FFFFFF_t_70]: /images/20220204/2248acb261134cacb5eefd4b7d0271a3.png
[20190507210924168.png]: /images/20220204/ad583b89e31d44a68a9115c7aa56cd8c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NTgyNjA0_size_16_color_FFFFFF_t_70 1]: /images/20220204/3de2e56c97124e1fb2300be0845ad4f3.png
[2019050719504922.png]: /images/20220204/b045fc0cc96c4163892a3481aeedcb90.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NTgyNjA0_size_16_color_FFFFFF_t_70 2]: /images/20220204/e3eaa8192f9046cd8e8047dc5f801ba5.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NTgyNjA0_size_16_color_FFFFFF_t_70 3]: /images/20220204/5ac8678cd2ee4f3b93461a18f4d7c23b.png
[2019050720512119.png]: /images/20220204/aab973ec06b645b9b62ba4996c1bee07.png