SpringBoot SpringCloud学习

SpringBoot SpringCloud学习

快速创建应用，简化配置，大量使用注解配置，创建可执行的jar工程，默认读取根目录的application.properties/application.yml文件，bootstrap.yml

1. 创建基本maven工程，修改pom.xml，完整内容如下

<parent>
	<groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.0.1.RELEASE</version>
</parent>
<dependencyManagement>
    <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
	            <artifactId>spring-cloud-dependencies</artifactId>
	            <version>Finchley.SR1</version>
	            <type>pom</type>
	            <scope>import</scope>
	        </dependency>
    </dependencies>
</dependencyManagement>
<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>
    <!-- 集成spring Data -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-jpa</artifactId>
    </dependency>
    <!-- mysql 驱动 -->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
    </dependency>
    <!-- 阿里巴巴数据源包 -->
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>druid</artifactId>
        <version>1.0.9</version>
    </dependency>
    <dependency>
        <groupId>commons-validator</groupId>
        <artifactId>commons-validator</artifactId>
        <version>1.4.0</version>
    </dependency>
    <dependency>
        <groupId>org.hibernate</groupId>
        <artifactId>hibernate-ehcache</artifactId>
    </dependency>
	<!-- 集成eureka服务	-->
	<dependency>
	  	<groupId>org.springframework.cloud</groupId>
	  	<artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
	</dependency>
    <!-- jsp配置 -->
    <dependency>
        <groupId>org.apache.tomcat.embed</groupId>
        <artifactId>tomcat-embed-jasper</artifactId>
        <scope>provided</scope>
    </dependency>
    <dependency>
        <groupId>javax.servlet</groupId>
        <artifactId>jstl</artifactId>
    </dependency>
    <!-- 测试环境依赖 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
</dependencies>

<build>
    <sourceDirectory>src/main/java</sourceDirectory>
    <resources>
        <resource>
            <directory>src/main/resources</directory>
        </resource>
    </resources>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
            <configuration>
                <outputDirectory>../deploy</outputDirectory>
                <classifier>exec</classifier>
            </configuration>
        </plugin>

        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-jar-plugin</artifactId>
            <configuration>
                <outputDirectory>../deploy</outputDirectory>
            </configuration>
        </plugin>
    </plugins>
</build>

2. 新建Application.java类，添加注解配置

@SpringBootApplication
@EnableDiscoveryClient
@PropertySource("classpath:/jdbc.properties")
@EntityScan(basePackageClasses = IdEntity.class)

3. 添加main方法

public static void main(String[] args) {

    SpringApplication.run(Application1.class, args);
    
}

4. 使用RestTemplate调用远程服务

@Bean
@LoadBalanced
public RestTemplate restTemplate() {
    RestTemplate template = new RestTemplate();
    SimpleClientHttpRequestFactory factory = (SimpleClientHttpRequestFactory) template.getRequestFactory();
    factory.setConnectTimeout(3000);
    factory.setReadTimeout(3000);
    return template;
}

1. 在method上使用注解LoadBalanced表示restTemplate使用LoadBalancerClient执行请求。
2. 使用时，可以直接引入依赖，然后根据serverId + 服务url调用，springCloud会自动从zookeeper服务中获取可用的服务

//serviceId = foo, 服务url= /user
ResponseEntity<User> resp = restTemplate.getForEntity("http://foo/user", User.class);

5. 配置数据源

添加配置文件

spring.datasource.url: jdbc:mysql://192.168.1.144:3306/spttopup?useUnicode=true&characterEncoding=UTF-8
spring.datasource.username: spttestuser
spring.datasource.password: sptuserpasswd
spring.datasource.driver: com.mysql.jdbc.Driver
spring.datasource.filters: stat
spring.datasource.showSql: true
spring.datasource.maxActive: 20
spring.datasource.initialSize: 1
spring.datasource.maxWait: 60000
spring.datasource.minIdle: 1
spring.datasource.timeBetweenEvictionRunsMillis: 60000
spring.datasource.minEvictableIdleTimeMillis: 300000
spring.datasource.validationQuery: select 'x'
spring.datasource.testWhileIdle: true
spring.datasource.testOnBorrow: false
spring.datasource.testOnReturn: false
spring.datasource.poolPreparedStatements: true
spring.datasource.maxOpenPreparedStatements: 20

添加对应的配置类DataSourceConfig.java，在类头部添加注解@Component
@ConfigurationProperties(prefix = “spring.datasource”)，启动时，会自动将对应的配置值赋给同名的属性

private String driver;
private String url;
private String username;
private String password;
private int initialSize;
private int minIdle;
private int maxActive;
private int maxWait;
private int timeBetweenEvictionRunsMillis;
private int 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;

添加DataSource配置

@Bean // 声明其为Bean实例
@Primary // 在同样的DataSource中，首先使用被标注的DataSource
public javax.sql.DataSource dataSource() {
    DruidDataSource datasource = new DruidDataSource();
    datasource.setUrl(url);
    datasource.setUsername(username);
    datasource.setPassword(password);
    datasource.setDriverClassName(driver);
    // configuration
    datasource.setInitialSize(initialSize);
    datasource.setMinIdle(minIdle);
    datasource.setMaxActive(maxActive);
    datasource.setMaxWait(maxWait);
    datasource.setTimeBetweenEvictionRunsMillis(timeBetweenEvictionRunsMillis);
    datasource.setMinEvictableIdleTimeMillis(minEvictableIdleTimeMillis);
    datasource.setValidationQuery(validationQuery);
    datasource.setTestWhileIdle(testWhileIdle);
    datasource.setTestOnBorrow(testOnBorrow);
    datasource.setTestOnReturn(testOnReturn);
    datasource.setPoolPreparedStatements(poolPreparedStatements);
    datasource.setMaxPoolPreparedStatementPerConnectionSize(maxPoolPreparedStatementPerConnectionSize);
    try {
        datasource.setFilters(filters);
    } catch (SQLException e) {
        logger.error("druid configuration initialization filter", e);
    }
    datasource.setConnectionProperties(connectionProperties);
    return datasource;
}

6. 集成zookeeper

<!-- 集成zookeeper服务 -->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-zookeeper-discovery</artifactId>
</dependency>

在application.properties里面添加连接配置

spring.cloud.zookeeper.connect-string: 192.168.1.51:2181

注意，如果你依赖了spring-cloud-starter-zookeeper-config，以上配置想必须写在bootstrap.yml中

7. 集成eureka服务

• eurekaServer配置

新建eureka server工程，添加依赖

<dependency>
	<groupId>org.springframework.cloud</groupId>
	<artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
</dependency>

添加注解配置

@SpringBootApplication
@EnableEurekaServer
@EnableDiscoveryClient
public class EurekaApplication {

	public static void main(String[] args) {
		SpringApplication.run(EurekaApplication.class, args);
	}
	
	
	@Bean
	public Filter characterEncodingFilter() {
		CharacterEncodingFilter characterEncodingFilter =new CharacterEncodingFilter();
		characterEncodingFilter.setEncoding("UTF-8");
		characterEncodingFilter.setForceEncoding(true);
		
		return characterEncodingFilter;
	}

}

在application.yml中添加配置文件

server:
  port: 8888
eureka:

  client:
    registerWithEureka: false
    fetchRegistry: false
    serviceUrl:
      defaultZone: http://localhost:8888/eureka/
  
  server:
    waitTimeInMsWhenSyncEmpty: 0

• eurekaClient配置

添加依赖

<!-- 集成eureka服务	-->
<dependency>
	<groupId>org.springframework.cloud</groupId>
	<artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
</dependency>

在application.properties里面添加配置

# eureka
eureka.instance.leaseRenewalIntervalInSeconds:10
eureka.instance.metadataMap.instanceId:${vcap.application.instance_id:${spring.application.name}:${spring.application.instance_id:${random.value}}}
eureka.client.registryFetchIntervalSeconds:5
eureka.client.serviceUrl.defaultZone:http://localhost:8888/eureka/

在启动类里添加注解

@EnableDiscoveryClient

8. 其他配置

服务名配置，在bootstrap.yml中添加

spring:
  application:
    name: foo1

端口配置，application.yml

server:
  port: 8081

jsp模板配置，application.yml

spring:
   mvc:
     view:
       prefix: /WEB-INF/jsp/
       suffix: .jsp

hibernate相关配置

# 打开hibernate统计信息
spring.jpa.properties.hibernate.generate_statistics=true
# 打开二级缓存
spring.jpa.properties.hibernate.cache.use_second_level_cache=true
# 打开查询缓存
spring.jpa.properties.hibernate.cache.use_query_cache=true
# 指定缓存provider
spring.jpa.properties.hibernate.cache.region.factory_class=org.hibernate.cache.ehcache.SingletonEhCacheRegionFactory
# 配置shared-cache-mode
spring.jpa.properties.javax.persistence.sharedCache.mode=ENABLE_SELECTIVE
#spring.jpa.hibernate.naming.physical-strategy=org.hibernate.boot.model.naming.PhysicalNamingStrategyStandardImpl
spring.jpa.show-sql=true

log配置

logging.level.root=INFO
logging.level.org.springframework.web=INFO
logging.level.org.hibernate=ERROR

9. 单元测试

@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest(classes = Application1.class)
public class DictServiceTest {
    @Autowired
    private DictService dictService;
    @Test
    public void save() throws Exception {
        DictType entity = new DictType();
        entity.setDictTypeCd("test_14");
        entity.setDictTypeName("测试_04");
        dictService.save(entity);
        System.out.println("-------------");
    }
}

10. 集成SpringSession

添加jar依赖

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

application.properties里面添加redis链接配置

spring.redis.host=192.168.1.144
spring.redis.port=6379

添加注解配置

@EnableRedisHttpSession
public class HttpSessionConfig {

	
}

11. 集成mybatis

添加jar依赖

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

添加注解配置

@MapperScan(basePackages = "com.spt.master.dao", annotationClass = MyBatisDao.class)

添加sessionFactory配置

@Bean(name = "sqlSessionFactory")
@Primary
public SqlSessionFactory rdsSqlSessionFactory(DataSource rdsDataSource) throws Exception {
	logger.info("*************************sqlSessionFactory:begin***********************");

	VFS.addImplClass(SpringBootVFS.class);

	SqlSessionFactoryBean sessionFactory = new SqlSessionFactoryBean();
	sessionFactory.setDataSource(rdsDataSource);
	sessionFactory.setTypeAliasesPackage("com.spt.master.entity,com.spt.master.dto,com.spt.commutil.entity");
	//sessionFactory.setTypeAliases(new Class<?>[] { TblSptDictionaryEntity.class });
	// sessionFactory.setTypeHandlersPackage(properties.typeHandlerPackage);
	PaginationInterceptor interceptor = new PaginationInterceptor();
	Properties props = new Properties();
	props.setProperty("jdbc.type", "mysql");
	interceptor.setProperties(props);
	sessionFactory.setPlugins(new Interceptor[] { interceptor });
	ResourcePatternResolver resolver = new PathMatchingResourcePatternResolver();
	sessionFactory.setMapperLocations(resolver.getResources("classpath:mybatis/mappers/*.xml"));

	// sessionFactory
	// .setConfigLocation(new
	// PathMatchingResourcePatternResolver().getResource(properties.configLocation));

	SqlSessionFactory resultSessionFactory = sessionFactory.getObject();

	// logger.info("===typealias==>" +
	// resultSessionFactory.getConfiguration().getTypeAliasRegistry().getTypeAliases());

	logger.info("*************************sqlSessionFactory:successs:" + resultSessionFactory);

	return resultSessionFactory;
}

12. SpringBoot瘦身

配置插件，过滤不常变动的jar包

<plugin>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-maven-plugin</artifactId>
	<configuration>
	<outputDirectory>${jar.output}</outputDirectory>
	<layout>ZIP</layout>
	<excludeGroupIds>
		org.springframework.boot,
		org.springframework,
		org.springframework.data,
		org.mybatis.spring.boot,
		org.mongodb,
		org.codehaus.groovy,
		redis.clients,
		org.attoparser,
		org.mybatis,
		org.springframework.session,
		com.github.0604hx,
		com.fasterxml.jackson.core,
		commons-beanutils,
		commons-codec,
		org.apache.commons,
		org.apache.tomcat.embed,
		org.apache.tomcat,
		mysql,
		org.hibernate,
		org.slf4j,
		com.jayway,
		org.jboss,
		com.alibaba,
		com.fasterxml,
		commons-collections,
		ch.qos.logback,
		org.scala-lang,
		org.yaml,
		org.jboss.logging,
		javax.validation,
		nz.net.ultraq.thymeleaf,
		org.thymeleaf,
		ognl,
		org.unbescape,
		org.javassist
	</excludeGroupIds>
	
	</configuration>
</plugin>

配置插件，copy所有的依赖包到指定目录

<plugin>
	<groupId>org.apache.maven.plugins</groupId>
	<artifactId>maven-dependency-plugin</artifactId>
	<version>3.0.1</version>
	<inherited>true</inherited>
	<executions>
		<execution>
			<id>copy-dependencies</id>
			<phase>install</phase>
			<goals>
				<goal>copy-dependencies</goal>
			</goals>
			<configuration>
				<includeScope>runtime</includeScope>
				<outputDirectory>${basedir}/libs</outputDirectory>
				<overWriteReleases>false</overWriteReleases>
				<overWriteSnapshots>false</overWriteSnapshots>
				<overWriteIfNewer>true</overWriteIfNewer>
				<excludeGroupIds>
				com.autrade.spt,
				com.autrade
				</excludeGroupIds>
			</configuration>
		</execution>
	</executions>
</plugin>

配置启动参数

java -jar -Dloader.path="libs/" .\adminServer-0.0.1-SNAPSHOT.jar 

13. 工程启动

mvn spring-boot:run

也可以直接运行main方法

14. 参考资料

• http://projects.spring.io/spring-boot/
• http://projects.spring.io/spring-cloud/
• 使用Spring Cloud Feign作为HTTP客户端调用远程HTTP服务
• springcloud config 入门
• SpringBoot初始教程之统一异常处理