SpringBoot中配置文件bootstrap和application的区别比较

大家都知道 Spring Boot 中有两种配置文件

  • bootstrap (.yml 或者 .properties)
  • application (.yml 或者 .properties)

Spring Cloud 的官方文档有关于它们的介绍

https://cloud.spring.io/spring-cloud-static/Greenwich.SR1/single/spring-cloud.html#_the_bootstrap_application_context

大概意思是

Spring Cloud有一个“引导上下文”的概念,这是主应用程序的父上下文。引导上下文负责从配置服务器加载配置属性,以及解密外部配置文件中的属性。和主应用程序加载application.(yml或.properties)中的属性不同,引导上下文加载bootstrap.中的属性。配置在bootstrap.*中的属性有更高的优先级,因此默认情况下它们不能被本地配置覆盖。

如果想禁用引导过程,可设置spring.cloud.bootstrap.enabled=false。

因此,可以对比总结出 application 和 bootstrap 配置文件的几个特性

  • boostrap 由父 ApplicationContext 加载,比 applicaton 优先加载
  • boostrap 里面的属性不能被覆盖

bootstrap 和 application 的应用场景

application 配置文件主要用于 Spring Boot 项目的自动化配置
bootstrap 配置文件的应用场景:①使用 Spring Cloud Config 配置中心时,这时需要在 bootstrap 配置文件中添加连接到配置中心的配置属性来加载外部配置中心的配置信息②一些固定的不能被覆盖的属性③一些加密/解密的场景

Spring Cloud 工程师也针对网友关于这个问题的提问进行了回答。

0

Spring Cloud Config里使用Git作为后端存储来开发ConfigServer

一、准备一个Git仓库

比如GitHub或者Gitee都可以,这边我使用https://gitee.com/791202/spring-cloud-config-repo,这个地址由于涉及隐私,已经修改了。

二、在Git仓库里添加配置文件

例如:

  • deviceservice-foo.properties
  • deviceservice-foo-dev.properties
  • deviceservice-foo-test.properties
  • deviceservice-foo-production.properties

内容分别为:

  • profile=default-1.0
  • profile=dev-1.0
  • profile=test-1.0
  • profile=production-1.0

为了测试版本控制,为该Git仓库创建config-label-v2.0分支,并将各个配置文件中的1.0改为2.0。

三、创建一个新的Maven工程

其中ArtifactId为deviceservice-config-server,并添加如下依赖

四、启动类

注意启动类上的注解@EnableConfigServer,它是用来声明一个Config Server。

五、配置文件application.yml

六、使用Config Server的端点获取配置文件的内容

如上配置都搭建好了,那一个Config Server就算整好了,下面是要获取里面的内容。

端点与配置文件的映射规则

  • /{application}/{profile}[/{label}]
  • /{application}-{profile}.yml
  • /{label}/{application}-{profile}.yml
  • /{application}-{profile}.properties
  • /{label}/{application}-{profile}.properties

以上端点都可以映射到{application}-{profile}.properties这个配置文件,{application}表示微服务的名称,{label}对应Git仓库的分支,默认是master。

所以我们可使用如下URL访问到Git仓库master分支的deviceservice-foo-dev.properties。

  • http://localhost:8080/deviceservice-foo/dev
  • http://localhost:8080/deviceservice-foo-dev.properties
  • http://localhost:8080/deviceservice-foo-dev.yml

七、测试

1.访问http://localhost:8080/deviceservice-foo/dev

从结果我们可以直观地看到应用名称、项目profile、Git label、Git version、配置文件URL、配置详情等信息。

2.访问http://localhost:8080/deviceservice-foo-dev.properties

profile:dev-1.0

3.访问http://localhost:8080/config-label-v2.0/deviceservice-foo-dev.properties

profile:dev-2.0

可以看到获得了config-label-v2.0分支中的配置文件。

八、注意

访问http://localhost:8080/deviceservice-foo/dev,结果中类似https://gitee.com/791202/spring-cloud-config-repo/deviceservice-foo-dev.properties的URL并不能访问。这是正常的,因为它并不代表配置文件的实际URL路径,而只是一个标识。

0

SQLite + mybatis 使用教程

1.创建user表

创建的数据库文件保存在“C\mydb.db”中

2.准备依赖的jar包

3.configuration.xml

4.userMapper.xml

5.UserVo.java

6. UserTest.java

0

如何在IDEA中安装、配置、使用SonarLint插件?

一、安装SonarLint

可以分为在线安装和离线安装。

1.在线安装

在IDEA菜单栏选择File->Settings,左边栏选择Plugins

在线安装选择Browse repositories,搜索Sonar,选择SonarLint进行安装,之后重启IDEA即可

2.离线安装

2.1下载离线安装包:

官方地址

http://plugins.jetbrains.com/plugin/7973-sonarlint/versions

如果官方地址打不开,或者太慢,可以使用这个百度云下载地址

链接:https://pan.baidu.com/s/19daJr27OCjzSRFqAbHzJUg
提取码:oous

2.2下载对应版本的插件压缩包:

可以看到已经有最新的2020版本的了

2.3将插件导入idea。

File->Settings,左边栏选择Plugins,离线安装选择 Install Plugin from disk…,选择下载包所在的位置,导入即可。

2.4导入后重启IDEA。

二、配置 SonarLint

Ctrl+Alt+S呼叫出设置菜单,过滤窗口可以输入sonar,找到下图菜单。
SonarLint General Settings :针对IDEA所有打开项目之后的SonarLint通用配置。
SonarLint Project Settings :针对当前这一个项目配置生效。

配置SonarLint General Settings

点击右侧红框里的+号

配置SonarQube

SonarQube是一个用于管理代码质量的开放平台,可以快速的定位代码中潜在的或者明显的错误。目前支持java,C#,C/C++,Python,PL/SQL,Cobol,JavaScrip,Groovy等二十几种编程语言的代码质量管理与检测。

填写配置的名称,这边使用的是本地sonarQube,选择的右边配置,输入sonarQube的URL,然后点击Next

设置认证方式

有Token和用户名密码两种方式,大家可以根据自己的情况选择对应方式进行配置。

这边我使用用户名密码方式

配置是否开启自动分析

SonarLint安装完后,默认情况下是自动检测项目代码的。若觉得影响效率,可通过菜单Settings->Other Settings->SonarLint General Settings进行设置。

就是这里红框Automatically trigger analysis。

配置更新获取远程SonarQube

当远程SonarQube有更新,可以点击下面的按钮Update Binding进行更新。

配置SonarLint Project Settings

  1. 选择下图中SonarLint Project Settings的菜单
  2. 勾选Enable binding to remote SonarQube server
  3. 在Bind to server 右边下拉选择刚才配置的 sonar配置名称
  4. 配置SonarQube project,可以点击Search in List,再弹出框里找到想使用的某个规则选择想使用的即可.
  5. 点击Apply使得配置生效保存

二、在IDEA中使用SonarLint

安装SonarLint插件重启后,IDEA Tool Windows部分会出现SonarLint View。如果没有出现,选择菜单View->Tool Windows->SonarLint会显示

在项目目录结构中选择要分析的文件夹或是代码文件,右键菜单 Anaylyze->Analyze with SonarLint Https…,或者选中后使用快捷键 Ctrl+Shift+S

如果快捷键冲突参考下图
还是Ctrl+Alt+S打开IDEA设置页面,搜索keyMap,再在右侧搜索sonar,找到SonarLint的快捷键设置,修改为想使用的快捷键

检测完毕后,会在SonarLint Tool View中显示出检测的问题,以类名称进行分类。各类的issue,分为阻断、严重、主要、提示和次要,问题严重性依次降低。点击issue,在右侧会出现对应的Rule,可参照进行修改。

0

SpringBoot使用教程

Spring介绍

1.1、SpringBoot简介

在您第1次接触和学习Spring框架的时候,是否因为其繁杂的配置而退却了?在你第n次使用Spring框架的时候,是否觉得一堆反复黏贴的配置有一些厌烦?那么您就不妨来试试使用Spring Boot来让你更易上手,更简单快捷地构建Spring应用!

Spring Boot让我们的Spring应用变的更轻量化。比如:你可以仅仅依靠一个Java类来运行一个Spring引用。你也可以打包你的应用为jar并通过使用java -jar来运行你的Spring Web应用。

Spring Boot的主要优点:

  • 为所有Spring开发者更快的入门
  • 开箱即用,提供各种默认配置来简化项目配置
  • 内嵌式容器简化Web项目
  • 没有冗余代码生成和XML配置的要求

本章主要目标完成Spring Boot基础项目的构建,并且实现一个简单的Http请求处理,通过这个例子对Spring Boot有一个初步的了解,并体验其结构简单、开发快速的特性。

1.2、系统要求:

Java 7及以上

Spring Framework 4.1.5及以上

本文采用Java 1.8.0_73Spring Boot 1.3.2调试通过。

二、快速入门

2.1、创建一个Maven工程

名为”springboot-helloworld” 类型为Jar工程项目

2.2、pom文件引入依赖

spring-boot-starter-parent作用 在pom.xml中引入spring-boot-start-parent,spring官方的解释叫什么stater poms,它可以提供dependency management,也就是说依赖管理,引入以后在申明其它dependency的时候就不需要version了,后面可以看到。 spring-boot-starter-web作用 springweb 核心组件 spring-boot-maven-plugin作用  如果我们要直接Main启动spring,那么以下plugin必须要添加,否则是无法启动的。如果使用maven 的spring-boot:run的话是不需要此配置的。(我在测试的时候,如果不配置下面的plugin也是直接在Main中运行的。)

2.3、编写HelloWorld服务

创建package命名为com.itmayiedu.controller(根据实际情况修改)

创建HelloController类,内容如下

2.4、@RestController

在上加上RestController 表示修饰该Controller所有的方法返回JSON格式,直接可以编写

Restful接口

2.5、@EnableAutoConfiguration

注解:作用在于让 Spring Boot   根据应用所声明的依赖来对 Spring 框架进行自动配置
        这个注解告诉Spring Boot根据添加的jar依赖猜测你想如何配置Spring。由于spring-boot-starter-web添加了Tomcat和Spring MVC,所以auto-configuration将假定你正在开发一个web应用并相应地对Spring进行设置。

2.6 SpringApplication.run(HelloController.class, args);

标识为启动类

2.6.1@SpringbootApplication

 使用@SpringbootApplication注解  可以解决根类或者配置类(我自己的说法,就是main所在类)头上注解过多的问题,一个@SpringbootApplication相当于@Configuration,@EnableAutoConfiguration和 @ComponentScan 并具有他们的默认属性值

@SpringBootApplication //等同于 @Configuration @EnableAutoConfiguration @ComponentScanpublic

class Application {   

    public static void main(String[] args) {

        SpringApplication.run(Application.class, args);

    }

2.7、SpringBoot启动方式1

Springboot默认端口号为8080

启动主程序,打开浏览器访问http://localhost:8080/index,可以看到页面输出Hello World

2.8、SpringBoot启动方式2

@ComponentScan(basePackages = “com.itmayiedu.controller”)—控制器扫包范围

Web开发

3.1、静态资源访问

在我们开发Web应用的时候,需要引用大量的js、css、图片等静态资源。

默认配置

Spring Boot默认提供静态资源目录位置需置于classpath下,目录名需符合如下规则:

/static

/public

/resources

/META-INF/resources

举例:我们可以在src/main/resources/目录下创建static,在该位置放置一个图片文件。启动程序后,尝试访问http://localhost:8080/D.jpg。如能显示图片,配置成功。

3.2、全局捕获异常

@ExceptionHandler 表示拦截异常

  • @ControllerAdvice 是 controller 的一个辅助类,最常用的就是作为全局异常处理的切面类
  • @ControllerAdvice 可以指定扫描范围
  • @ControllerAdvice 约定了几种可行的返回值,如果是直接返回 model 类的话,需要使用 @ResponseBody 进行 json 转换
    • 返回 String,表示跳到某个 view
    • 返回 modelAndView
    • 返回 model + @ResponseBody

3.3、渲染Web页面

渲染Web页面

在之前的示例中,我们都是通过@RestController来处理请求,所以返回的内容为json对象。那么如果需要渲染html页面的时候,要如何实现呢?

模板引擎

在动态HTML实现上Spring Boot依然可以完美胜任,并且提供了多种模板引擎的默认配置支持,所以在推荐的模板引擎下,我们可以很快的上手开发动态网站。

Spring Boot提供了默认配置的模板引擎主要有以下几种:

  • Thymeleaf
  • FreeMarker
  • Velocity
  • Groovy
  • Mustache

Spring Boot建议使用这些模板引擎,避免使用JSP,若一定要使用JSP将无法实现Spring Boot的多种特性,具体可见后文:支持JSP的配置

当你使用上述模板引擎中的任何一个,它们默认的模板配置路径为:src/main/resources/templates。当然也可以修改这个路径,具体如何修改,可在后续各模板引擎的配置属性中查询并修改。

3.4、使用Freemarker模板引擎渲染web视图

3.4.1、pom文件引入:

3.4.2、后台代码

在src/main/resources/创建一个templates文件夹,后缀为*.ftl

3.4.3、前台代码

3.4.4、Freemarker其他用法

@RequestMapping(“/index”) public String index(Map<String, Object> map) { map.put(“name”,”###蚂蚁课堂###”); map.put(“sex”,1); List<String> userlist=new ArrayList<String>(); userlist.add(“余胜军”); userlist.add(“张三”); userlist.add(“李四”); map.put(“userlist”,userlist); return “index”; }
<!DOCTYPE html> <html> <head lang=”en”> <meta charset=”UTF-8″ /> <title>首页</title> </head> <body> ${name} <#if sex==1> 男 <#elseif sex==2> 女 <#else> 其他   </#if>   <#list userlist as user> ${user} </#list> </body> </html>

3.4.5、Freemarker配置

新建application.properties文件

######################################################## ###FREEMARKER (FreeMarkerAutoConfiguration) ######################################################## spring.freemarker.allow-request-override=false spring.freemarker.cache=true spring.freemarker.check-template-location=true spring.freemarker.charset=UTF-8 spring.freemarker.content-type=text/html spring.freemarker.expose-request-attributes=false spring.freemarker.expose-session-attributes=false spring.freemarker.expose-spring-macro-helpers=false #spring.freemarker.prefix= #spring.freemarker.request-context-attribute= #spring.freemarker.settings.*= spring.freemarker.suffix=.ftl spring.freemarker.template-loader-path=classpath:/templates/ #comma-separated list #spring.freemarker.view-names= # whitelist of view names that can be resolved

3.5、使用JSP渲染Web视图

3.5.1、pom文件引入以下依赖

<parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version>1.3.3.RELEASE</version> </parent> <dependencies> <!– SpringBoot 核心组件 –> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-tomcat</artifactId> </dependency> <dependency> <groupId>org.apache.tomcat.embed</groupId> <artifactId>tomcat-embed-jasper</artifactId> </dependency> </dependencies>

3.5.2、在application.properties创建以下配置

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

3.5.3、后台代码

@Controller public class IndexController { @RequestMapping(“/index”) public String index() { return “index”; } }

数据访问

4.1、springboot整合使用JdbcTemplate

4.1.1 pom文件引入

<parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version>1.5.2.RELEASE</version> </parent> <dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-jdbc</artifactId> </dependency> <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <version>5.1.21</version> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-test</artifactId> <scope>test</scope> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> </dependencies>

4.1.2 application.properties新增配置

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

4.1.3 UserService类

@Service public class UserServiceImpl implements UserService { @Autowired private JdbcTemplate jdbcTemplate; public void createUser(String name, Integer age) { System.out.println(“ssss”); jdbcTemplate.update(“insert into users values(null,?,?);”, name, age); } }

4.1.4 App类

@ComponentScan(basePackages = “com.itmayiedu”) @EnableAutoConfiguration public class App { public static void main(String[] args) { SpringApplication.run(App.class, args); } }

注意: spring-boot-starter-parent要在1.5以上

4.2、springboot整合使用mybatis

4.2.1、pom文件引入

<parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version>1.3.2.RELEASE</version> <relativePath /> <!– lookup parent from repository –> </parent> <dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-test</artifactId> <scope>test</scope> </dependency> <dependency> <groupId>org.mybatis.spring.boot</groupId> <artifactId>mybatis-spring-boot-starter</artifactId> <version>1.1.1</version> </dependency> <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <version>5.1.21</version> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> </dependencies>

4.2.2、配置文件引入

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

4.2.3、Mapper代码

public interface UserMapper { @Select(“SELECT * FROM USERS WHERE NAME = #{name}”) User findByName(@Param(“name”) String name); @Insert(“INSERT INTO USERS(NAME, AGE) VALUES(#{name}, #{age})”) int insert(@Param(“name”) String name, @Param(“age”) Integer age); }

4.2.4、启动方式

@ComponentScan(basePackages = “com.itmayiedu”) @MapperScan(basePackages = “com.itmayiedu.mapper”) @SpringBootApplication public class App { public static void main(String[] args) { SpringApplication.run(App.class, args); } }

4.3、springboot整合使用springjpa

4.3.1 pom文件引入依赖

<parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version>1.4.2.RELEASE</version> </parent> <dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-jpa</artifactId> </dependency> <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <version>5.1.21</version> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> </dependencies>

4.3.2 创建User实体类

@Entity(name = “users”) public class User { @Id @GeneratedValue private Integer id; @Column private String name; @Column private Integer age; // ..get/set方法 }

4.3.3 创建UserDao

public interface UserDao extends JpaRepository<User, Integer> { }

4.3.4 创建IndexController

@RestController public class IndexController { @Autowired private UserDao userDao; @RequestMapping(“/index”) public String index(Integer id) { User findUser = userDao.findOne(id); System.out.println(findUser.getName()); return “success”; } }

4.3.5 启动项目

@ComponentScan(basePackages = { “com.itmayiedu” }) @EnableJpaRepositories(basePackages = “com.itmayiedu.dao”) @EnableAutoConfiguration @EntityScan(basePackages = “com.itmayiedu.entity”) public class App { public static void main(String[] args) { SpringApplication.run(App.class, args); } }

4.4、springboot整合多数据源

同学们思考下,你们在项目中有使用到多数据源吗?

4.4.1配置文件中新增两个数据源

spring.datasource.test1.driverClassName = com.mysql.jdbc.Driver spring.datasource.test1.url = jdbc:mysql://localhost:3306/test01?useUnicode=true&characterEncoding=utf-8 spring.datasource.test1.username = root spring.datasource.test1.password = root spring.datasource.test2.driverClassName = com.mysql.jdbc.Driver spring.datasource.test2.url = jdbc:mysql://localhost:3306/test02?useUnicode=true&characterEncoding=utf-8 spring.datasource.test2.username = root spring.datasource.test2.password = root

4.4.2配置文件中新增两个数据源

@Configuration // 注册到springboot容器中 @MapperScan(basePackages = “com.itmayiedu.user1”, sqlSessionFactoryRef = “test1SqlSessionFactory”) public class DataSource1Config { /** * * @methodDesc: 功能描述:(配置test1数据库) * @author: 余胜军 * @param: @return * @createTime:2017年9月17日 下午3:16:44 * @returnType:@return DataSource * @copyright:791202.com * @QQ:364850679 */ @Bean(name = “test1DataSource”) @Primary @ConfigurationProperties(prefix = “spring.datasource.test1”) public DataSource testDataSource() { return DataSourceBuilder.create().build(); } /** * * @methodDesc: 功能描述:(test1 sql会话工厂) * @author: sww * @param: @param * dataSource * @param: @return * @param: @throws * Exception * @createTime:2017年9月17日 下午3:17:08 * @returnType:@param dataSource * @returnType:@return * @returnType:@throws Exception SqlSessionFactory * @copyright: 791202.com * @QQ: 364850679 */ @Bean(name = “test1SqlSessionFactory”) @Primary public SqlSessionFactory testSqlSessionFactory(@Qualifier(“test1DataSource”) DataSource dataSource) throws Exception { SqlSessionFactoryBean bean = new SqlSessionFactoryBean(); bean.setDataSource(dataSource); // bean.setMapperLocations( // new PathMatchingResourcePatternResolver().getResources(“classpath:mybatis/mapper/test1/*.xml”)); return bean.getObject(); } /** * * @methodDesc: 功能描述:(test1 事物管理) * * @param: @param * dataSource * @param: @return * @param: @throws * Exception * @createTime:2017年9月17日 下午3:17:08 * @returnType:@param dataSource * @returnType:@return * @returnType:@throws Exception SqlSessionFactory * */ @Bean(name = “test1TransactionManager”) @Primary public DataSourceTransactionManager testTransactionManager(@Qualifier(“test1DataSource”) DataSource dataSource) { return new DataSourceTransactionManager(dataSource); } @Bean(name = “test1SqlSessionTemplate”) public SqlSessionTemplate testSqlSessionTemplate( @Qualifier(“test1SqlSessionFactory”) SqlSessionFactory sqlSessionFactory) throws Exception { return new SqlSessionTemplate(sqlSessionFactory); } }

4.4.2创建分包Mapper

public interface User1Mapper { @Insert(“insert into users values(null,#{name},#{age});”) public int addUser(@Param(“name”) String name, @Param(“age”) Integer age); }

4.4.3启动项目

@ComponentScan(basePackages = “com.itmayiedu”) @EnableAutoConfiguration public class App { public static void main(String[] args) { SpringApplication.run(App.class, args); } }

No qualifying bean of type [javax.sql.DataSource] is defined: expected single matching bean but found 2: test1DataSource,test2DataSource

事物管理

5.1.1springboot整合事物管理

springboot默认集成事物,只主要在方法上加上@Transactional即可

5.1.2SpringBoot分布式事物管理

使用springboot+jta+atomikos 分布式事物管理

5.1.2.1新增配置文件信息

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

5.1.2.2新增配置文件信息

# Mysql 1 mysql.datasource.test.url = jdbc:mysql://localhost:3306/test01?useUnicode=true&characterEncoding=utf-8 mysql.datasource.test.username = root mysql.datasource.test.password = root mysql.datasource.test.minPoolSize = 3 mysql.datasource.test.maxPoolSize = 25 mysql.datasource.test.maxLifetime = 20000 mysql.datasource.test.borrowConnectionTimeout = 30 mysql.datasource.test.loginTimeout = 30 mysql.datasource.test.maintenanceInterval = 60 mysql.datasource.test.maxIdleTime = 60 mysql.datasource.test.testQuery = select 1 # Mysql 2 mysql.datasource.test2.url =jdbc:mysql://localhost:3306/test02?useUnicode=true&characterEncoding=utf-8 mysql.datasource.test2.username =root mysql.datasource.test2.password =root mysql.datasource.test2.minPoolSize = 3 mysql.datasource.test2.maxPoolSize = 25 mysql.datasource.test2.maxLifetime = 20000 mysql.datasource.test2.borrowConnectionTimeout = 30 mysql.datasource.test2.loginTimeout = 30 mysql.datasource.test2.maintenanceInterval = 60 mysql.datasource.test2.maxIdleTime = 60 mysql.datasource.test2.testQuery = select 1

5.1.2.3 读取配置文件信息

package com.itmayiedu.config; import org.springframework.boot.context.properties.ConfigurationProperties; @ConfigurationProperties(prefix = “mysql.datasource.test”) public class DBConfig1 { private String url; private String username; private String password; private int minPoolSize; private int maxPoolSize; private int maxLifetime; private int borrowConnectionTimeout; private int loginTimeout; private int maintenanceInterval; private int maxIdleTime; private String testQuery; } package com.itmayiedu.config; import org.springframework.boot.context.properties.ConfigurationProperties; @ConfigurationProperties(prefix = “mysql.datasource.test1”) public class DBConfig2 { private String url; private String username; private String password; private int minPoolSize; private int maxPoolSize; private int maxLifetime; private int borrowConnectionTimeout; private int loginTimeout; private int maintenanceInterval; private int maxIdleTime; private String testQuery; }

5.1.2.4 创建多数据源

@Configuration // basePackages 最好分开配置 如果放在同一个文件夹可能会报错 @MapperScan(basePackages = “com.itmayiedu.test01”, sqlSessionTemplateRef = “testSqlSessionTemplate”) public class TestMyBatisConfig1 { // 配置数据源 @Primary @Bean(name = “testDataSource”) public DataSource testDataSource(DBConfig1 testConfig) throws SQLException { MysqlXADataSource mysqlXaDataSource = new MysqlXADataSource(); mysqlXaDataSource.setUrl(testConfig.getUrl()); mysqlXaDataSource.setPinGlobalTxToPhysicalConnection(true); mysqlXaDataSource.setPassword(testConfig.getPassword()); mysqlXaDataSource.setUser(testConfig.getUsername()); mysqlXaDataSource.setPinGlobalTxToPhysicalConnection(true); AtomikosDataSourceBean xaDataSource = new AtomikosDataSourceBean(); xaDataSource.setXaDataSource(mysqlXaDataSource); xaDataSource.setUniqueResourceName(“testDataSource”); xaDataSource.setMinPoolSize(testConfig.getMinPoolSize()); xaDataSource.setMaxPoolSize(testConfig.getMaxPoolSize()); xaDataSource.setMaxLifetime(testConfig.getMaxLifetime()); xaDataSource.setBorrowConnectionTimeout(testConfig.getBorrowConnectionTimeout()); xaDataSource.setLoginTimeout(testConfig.getLoginTimeout()); xaDataSource.setMaintenanceInterval(testConfig.getMaintenanceInterval()); xaDataSource.setMaxIdleTime(testConfig.getMaxIdleTime()); xaDataSource.setTestQuery(testConfig.getTestQuery()); return xaDataSource; } @Bean(name = “testSqlSessionFactory”) public SqlSessionFactory testSqlSessionFactory(@Qualifier(“testDataSource”) DataSource dataSource) throws Exception { SqlSessionFactoryBean bean = new SqlSessionFactoryBean(); bean.setDataSource(dataSource); return bean.getObject(); } @Bean(name = “testSqlSessionTemplate”) public SqlSessionTemplate testSqlSessionTemplate( @Qualifier(“testSqlSessionFactory”) SqlSessionFactory sqlSessionFactory) throws Exception { return new SqlSessionTemplate(sqlSessionFactory); } } package com.itmayiedu.datasource; import java.sql.SQLException; import javax.sql.DataSource; import org.apache.ibatis.session.SqlSessionFactory; import org.mybatis.spring.SqlSessionFactoryBean; import org.mybatis.spring.SqlSessionTemplate; import org.mybatis.spring.annotation.MapperScan; import org.springframework.beans.factory.annotation.Qualifier; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import com.atomikos.jdbc.AtomikosDataSourceBean; import com.itmayiedu.config.DBConfig1; import com.mysql.jdbc.jdbc2.optional.MysqlXADataSource; @Configuration // basePackages 最好分开配置 如果放在同一个文件夹可能会报错 @MapperScan(basePackages = “com.itmayiedu.test02”, sqlSessionTemplateRef = “test2SqlSessionTemplate”) public class TestMyBatisConfig2 { // 配置数据源 @Bean(name = “test2DataSource”) public DataSource testDataSource(DBConfig1 testConfig) throws SQLException { MysqlXADataSource mysqlXaDataSource = new MysqlXADataSource(); mysqlXaDataSource.setUrl(testConfig.getUrl()); mysqlXaDataSource.setPinGlobalTxToPhysicalConnection(true); mysqlXaDataSource.setPassword(testConfig.getPassword()); mysqlXaDataSource.setUser(testConfig.getUsername()); mysqlXaDataSource.setPinGlobalTxToPhysicalConnection(true); AtomikosDataSourceBean xaDataSource = new AtomikosDataSourceBean(); xaDataSource.setXaDataSource(mysqlXaDataSource); xaDataSource.setUniqueResourceName(“test2DataSource”); xaDataSource.setMinPoolSize(testConfig.getMinPoolSize()); xaDataSource.setMaxPoolSize(testConfig.getMaxPoolSize()); xaDataSource.setMaxLifetime(testConfig.getMaxLifetime()); xaDataSource.setBorrowConnectionTimeout(testConfig.getBorrowConnectionTimeout()); xaDataSource.setLoginTimeout(testConfig.getLoginTimeout()); xaDataSource.setMaintenanceInterval(testConfig.getMaintenanceInterval()); xaDataSource.setMaxIdleTime(testConfig.getMaxIdleTime()); xaDataSource.setTestQuery(testConfig.getTestQuery()); return xaDataSource; } @Bean(name = “test2SqlSessionFactory”) public SqlSessionFactory testSqlSessionFactory(@Qualifier(“test2DataSource”) DataSource dataSource) throws Exception { SqlSessionFactoryBean bean = new SqlSessionFactoryBean(); bean.setDataSource(dataSource); return bean.getObject(); } @Bean(name = “test2SqlSessionTemplate”) public SqlSessionTemplate testSqlSessionTemplate( @Qualifier(“test2SqlSessionFactory”) SqlSessionFactory sqlSessionFactory) throws Exception { return new SqlSessionTemplate(sqlSessionFactory); } }

5.1.2.4 启动加载配置

@EnableConfigurationProperties(value = { DBConfig1.class, DBConfig2.class })

日志管理

6.1使用log4j记录日志

6.1.2新建log4j配置文件

#log4j.rootLogger=CONSOLE,info,error,DEBUG log4j.rootLogger=info,error,CONSOLE,DEBUG log4j.appender.CONSOLE=org.apache.log4j.ConsoleAppender log4j.appender.CONSOLE.layout=org.apache.log4j.PatternLayout log4j.appender.CONSOLE.layout.ConversionPattern=%d{yyyy-MM-dd-HH-mm} [%t] [%c] [%p] – %m%n log4j.logger.info=info log4j.appender.info=org.apache.log4j.DailyRollingFileAppender log4j.appender.info.layout=org.apache.log4j.PatternLayout log4j.appender.info.layout.ConversionPattern=%d{yyyy-MM-dd-HH-mm} [%t] [%c] [%p] – %m%n log4j.appender.info.datePattern=’.’yyyy-MM-dd log4j.appender.info.Threshold = info log4j.appender.info.append=true #log4j.appender.info.File=/home/admin/pms-api-services/logs/info/api_services_info log4j.appender.info.File=/Users/dddd/Documents/testspace/pms-api-services/logs/info/api_services_info log4j.logger.error=error log4j.appender.error=org.apache.log4j.DailyRollingFileAppender log4j.appender.error.layout=org.apache.log4j.PatternLayout log4j.appender.error.layout.ConversionPattern=%d{yyyy-MM-dd-HH-mm} [%t] [%c] [%p] – %m%n log4j.appender.error.datePattern=’.’yyyy-MM-dd log4j.appender.error.Threshold = error log4j.appender.error.append=true #log4j.appender.error.File=/home/admin/pms-api-services/logs/error/api_services_error log4j.appender.error.File=/Users/dddd/Documents/testspace/pms-api-services/logs/error/api_services_error log4j.logger.DEBUG=DEBUG log4j.appender.DEBUG=org.apache.log4j.DailyRollingFileAppender log4j.appender.DEBUG.layout=org.apache.log4j.PatternLayout log4j.appender.DEBUG.layout.ConversionPattern=%d{yyyy-MM-dd-HH-mm} [%t] [%c] [%p] – %m%n log4j.appender.DEBUG.datePattern=’.’yyyy-MM-dd log4j.appender.DEBUG.Threshold = DEBUG log4j.appender.DEBUG.append=true #log4j.appender.DEBUG.File=/home/admin/pms-api-services/logs/debug/api_services_debug log4j.appender.DEBUG.File=/Users/dddd/Documents/testspace/pms-api-services/logs/debug/api_services_debug

6.2使用AOP统一处理Web请求日志

6.2.1POM文件新增依赖

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

6.2.2POM文件新增依赖

@Aspect @Component public class WebLogAspect { private Logger logger = LoggerFactory.getLogger(getClass()); @Pointcut(“execution(public * com.itmayiedu.controller..*.*(..))”) public void webLog() { } @Before(“webLog()”) public void doBefore(JoinPoint joinPoint) throws Throwable { // 接收到请求,记录请求内容 ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes(); HttpServletRequest request = attributes.getRequest(); // 记录下请求内容 logger.info(“URL : ” + request.getRequestURL().toString()); logger.info(“HTTP_METHOD : ” + request.getMethod()); logger.info(“IP : ” + request.getRemoteAddr()); Enumeration<String> enu = request.getParameterNames(); while (enu.hasMoreElements()) { String name = (String) enu.nextElement(); logger.info(“name:{},value:{}”, name, request.getParameter(name)); } } @AfterReturning(returning = “ret”, pointcut = “webLog()”) public void doAfterReturning(Object ret) throws Throwable { // 处理完请求,返回内容 logger.info(“RESPONSE : ” + ret); } }

缓存支持

7.1注解配置与EhCache使用

7.1.1 pom文件引入

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

7.1.2新建ehcache.xml 文件

<?xml version=“1.0” encoding=“UTF-8”?> <ehcache xmlns:xsi=“http://www.w3.org/2001/XMLSchema-instance” xsi:noNamespaceSchemaLocation=“http://ehcache.org/ehcache.xsd” updateCheck=“false”> <diskStore path=“java.io.tmpdir/Tmp_EhCache” /> <!– 默认配置 –> <defaultCache maxElementsInMemory=“5000” eternal=“false” timeToIdleSeconds=“120” timeToLiveSeconds=“120” memoryStoreEvictionPolicy=“LRU” overflowToDisk=“false” /> <cache name=“baseCache” maxElementsInMemory=“10000” maxElementsOnDisk=“100000” /> </ehcache>

配置信息介绍

  1.     <!–  
  2.        name:缓存名称。  
  3.        maxElementsInMemory:缓存最大个数。  
  4.        eternal:对象是否永久有效,一但设置了,timeout将不起作用。  
  5.        timeToIdleSeconds:设置对象在失效前的允许闲置时间(单位:秒)。仅当eternal=false对象不是永久有效时使用,可选属性,默认值是0,也就是可闲置时间无穷大。  
  6.        timeToLiveSeconds:设置对象在失效前允许存活时间(单位:秒)。最大时间介于创建时间和失效时间之间。仅当eternal=false对象不是永久有效时使用,默认是0.,也就是对象存活时间无穷大。  
  7.        overflowToDisk:当内存中对象数量达到maxElementsInMemory时,Ehcache将会对象写到磁盘中。  
  8.        diskSpoolBufferSizeMB:这个参数设置DiskStore(磁盘缓存)的缓存区大小。默认是30MB。每个Cache都应该有自己的一个缓冲区。  
  9.        maxElementsOnDisk:硬盘最大缓存个数。  
  10.        diskPersistent:是否缓存虚拟机重启期数据 Whether the disk store persists between restarts of the Virtual Machine. The default value is false.  
  11.        diskExpiryThreadIntervalSeconds:磁盘失效线程运行时间间隔,默认是120秒。  
  12.        memoryStoreEvictionPolicy:当达到maxElementsInMemory限制时,Ehcache将会根据指定的策略去清理内存。默认策略是LRU(最近最少使用)。你可以设置为FIFO(先进先出)或是LFU(较少使用)。  
  13.        clearOnFlush:内存数量最大时是否清除。  
  14.     –> 

7.1.3代码使用Cacheable

@CacheConfig(cacheNames = “baseCache”) public interface UserMapper { @Select(“select * from users where name=#{name}”) @Cacheable UserEntity findName(@Param(“name”) String name); }

7.1.4清除缓存

@Autowired private CacheManager cacheManager; @RequestMapping(“/remoKey”) public void remoKey() { cacheManager.getCache(“baseCache”).clear(); }

使用Redis做集中式缓存

其他内容

8.1、使用@Scheduled创建定时任务

在Spring Boot的主类中加入@EnableScheduling注解,启用定时任务的配置

@Component

public class ScheduledTasks {

private static final SimpleDateFormat dateFormat = new SimpleDateFormat(“HH:mm:ss”);

@Scheduled(fixedRate = 5000)

public void reportCurrentTime() {

System.out.println(“现在时间:” + dateFormat.format(new Date()));

}

}

8.2、使用@Async实现异步调用

启动加上@EnableAsync ,需要执行异步方法上加入 @Async

8.3、自定义参数

配置文件值

name=791202.com

配置文件值

@Value(“${name}”) private String name; @ResponseBody @RequestMapping(“/getValue”) public String getValue() { return name; }

8.4、多环境配置

spring.profiles.active=pre
application-dev.properties:开发环境 application-test.properties:测试环境 application-prod.properties:生产环境
 
 

8.5、修改端口号

server.port=8888

server.context-path=/itmayiedu

8.6、SpringBoot yml 使用

创建application.yml

server: port: 8090 context-path: /itmayiedu

8.7、发布打包

使用mvn clean清除以前的编译文件

使用mvn package 打包

使用java –jar 包名

如果报错没有主清单,在pom文件中新增

<build> <plugins> <plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-compiler-plugin</artifactId> <configuration> <source>1.8</source> <target>1.8</target> </configuration> </plugin> <plugin> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-maven-plugin</artifactId> <configuration> <maimClass>com.itmayiedu.app.App</maimClass> </configuration> <executions> <execution> <goals> <goal>repackage</goal> </goals> </execution> </executions> </plugin> </plugins> </build>
0

关闭SonarLint自动运行检查变为手动

关闭SonarLint自动检查代码

如果敲一行代码SonarLint插件就会自动检查,会太频繁,还会使电脑卡顿。

按如下步骤可以关闭自动检查,依次点击:File -> Settings 或直接Ctrl+Alt+S,搜索”SonarLint”,在Other Settings这一栏,如下图操作:

以后敲代码SonarLint就不会自动运行了。

手动运行SonarLint代码检查

停止SonarLint自动检测代码之后,可以使用Ctrl+Shift+S手动运行SonarLint检查代码。

0

Kafka面试题整理总结大全

1 .什么是kafka?

Kafka是分布式发布-订阅消息系统,它最初是由LinkedIn公司开发的,之后成为Apache项目的一部分,Kafka是一个分布式,可划分的,冗余备份的持久性的日志服务,它主要用于处理流式数据。

2 .为什么要使用 kafka,为什么要使用消息队列?

缓冲和削峰:上游数据时有突发流量,下游可能扛不住,或者下游没有足够多的机器来保证冗余,kafka在中间可以起到一个缓冲的作用,把消息暂存在kafka中,下游服务就可以按照自己的节奏进行慢慢处理。

解耦和扩展性:项目开始的时候,并不能确定具体需求。消息队列可以作为一个接口层,解耦重要的业务流程。只需要遵守约定,针对数据编程即可获取扩展能力。

冗余:可以采用一对多的方式,一个生产者发布消息,可以被多个订阅topic的服务消费到,供多个毫无关联的业务使用。

健壮性:消息队列可以堆积请求,所以消费端业务即使短时间死掉,也不会影响主要业务的正常进行。

异步通信:很多时候,用户不想也不需要立即处理消息。消息队列提供了异步处理机制,允许用户把一个消息放入队列,但并不立即处理它。想向队列中放入多少消息就放多少,然后在需要的时候再去处理它们。

3.Kafka中的ISR、AR又代表什么?ISR的伸缩又指什么?

  • ISR:In-Sync Replicas 副本同步队列
  • AR:Assigned Replicas 所有副本

ISR是由leader维护,follower从leader同步数据有一些延迟(包括延迟时间replica.lag.time.max.ms和延迟条数replica.lag.max.messages两个维度,当前最新的版本0.10.x中只支持replica.lag.time.max.ms这个维度),任意一个超过阈值都会把follower剔除出ISR, 存入OSR(Outof-Sync Replicas)列表,新加入的follower也会先存放在OSR中。AR=ISR+OSR。

4.kafka中的broker 是干什么的?

broker 是消息的代理,Producers往Brokers里面的指定Topic中写消息,Consumers从Brokers里面拉取指定Topic的消息,然后进行业务处理,broker在中间起到一个代理保存消息的中转站。

5.kafka中的 zookeeper 起到什么作用,可以不用zookeeper么?

zookeeper 是一个分布式的协调组件,早期版本的kafka用zk做meta信息存储,consumer的消费状态,group的管理以及 offset的值。考虑到zk本身的一些因素以及整个架构较大概率存在单点问题,新版本中逐渐弱化了zookeeper的作用。新的consumer使用了kafka内部的group coordination协议,也减少了对zookeeper的依赖,

但是broker依然依赖于ZK,zookeeper 在kafka中还用来选举controller 和检测broker是否存活等等。

6.kafka follower如何与leader同步数据?

Kafka的复制机制既不是完全的同步复制,也不是单纯的异步复制。完全同步复制要求All Alive Follower都复制完,这条消息才会被认为commit,这种复制方式极大的影响了吞吐率。而异步复制方式下,Follower异步的从Leader复制数据,数据只要被Leader写入log就被认为已经commit,这种情况下,如果leader挂掉,会丢失数据,kafka使用ISR的方式很好的均衡了确保数据不丢失以及吞吐率。Follower可以批量的从Leader复制数据,而且Leader充分利用磁盘顺序读以及send file(zero copy)机制,这样极大的提高复制性能,内部批量写磁盘,大幅减少了Follower与Leader的消息量差。

7.什么情况下一个 broker 会从 isr中踢出去?

leader会维护一个与其基本保持同步的Replica列表,该列表称为ISR(in-sync Replica),每个Partition都会有一个ISR,而且是由leader动态维护 ,如果一个follower比一个leader落后太多,或者超过一定时间未发起数据复制请求,则leader将其重ISR中移除 。

8.kafka 为什么那么快?

  • Cache:Filesystem Cache PageCache缓存
  • 顺序写:由于现代的操作系统提供了预读和写技术,磁盘的顺序写大多数情况下比随机写内存还要快。
  • Zero-copy:零拷技术减少拷贝次数
  • Batching of Messages:批量消息处理,合并小的请求,然后以流的方式进行交互,直顶网络上限。
  • Pull 拉模式: 使用拉模式进行消息的获取消费,与消费端处理能力相符。

9.kafka producer如何优化push速度

  • 增加线程
  • 提高 batch.size
  • 增加更多 producer 实例
  • 增加 partition 数
  • 设置 acks=-1 时,如果延迟增大:可以增大 num.replica.fetchers(follower 同步数据的线程数)来调解
  • 跨数据中心的传输,增加 socket 缓冲区设置以及 OS tcp 缓冲区设置

10.kafka producer push数据,ack  为 0, 1, -1 的时候代表啥, 设置 -1 的时候,什么情况下,leader 会认为一条消息 commit了?

  • 1(默认)  数据发送到Kafka后,经过leader成功接收消息的的确认,就算是发送成功了。在这种情况下,如果leader宕机了,则会丢失数据。
  • 0 生产者将数据发送出去就不管了,不去等待任何返回。这种情况下数据传输效率最高,但是数据可靠性确是最低的。
  • -1 producer需要等待ISR中的所有follower都确认接收到数据后才算一次发送完成,可靠性最高。当ISR中所有Replica都向Leader发送ACK时,leader才commit,这时候producer才能认为一个请求中的消息都commit了。

11.kafka unclean 配置代表啥,会对 spark streaming 消费有什么影响?

unclean.leader.election.enable 为true的话,意味着非ISR集合的broker 也可以参与选举,这样有可能就会丢数据,spark streaming在消费过程中拿到的 end offset 会突然变小,导致 spark streaming job挂掉。如果unclean.leader.election.enable参数设置为true,就有可能发生数据丢失和数据不一致的情况,Kafka的可靠性就会降低;而如果unclean.leader.election.enable参数设置为false,Kafka的可用性就会降低。

12.如果leader crash时,ISR为空怎么办?

kafka在Broker端提供了一个配置参数:unclean.leader.election,这个参数有两个值:

true(默认):允许不同步副本成为leader,由于不同步副本的消息较为滞后,此时成为leader,可能会出现消息不一致的情况。

false:不允许不同步副本成为leader,此时如果发生ISR列表为空,会一直等待旧leader恢复,降低了可用性。

13.kafka的message格式是什么样的?

一个Kafka的Message由一个固定长度的header和一个变长的消息体body组成。

header部分由一个字节的magic(文件格式)和四个字节的CRC32(用于判断body消息体是否正常)构成。

当magic的值为1的时候,会在magic和crc32之间多一个字节的数据:attributes(保存一些相关属性,比如是否压缩、压缩格式等等);如果magic的值为0,那么不存在attributes属性。

body是由N个字节构成的一个消息体,包含了具体的key/value消息。

14.kafka中consumer group 是什么概念?

同样是逻辑上的概念,是Kafka实现单播和广播两种消息模型的手段。同一个topic的数据,会广播给不同的group;同一个group中的worker,只有一个worker能拿到这个数据。换句话说,对于同一个topic,每个group都可以拿到同样的所有数据,但是数据进入group后只能被其中的一个worker消费。group内的worker可以使用多线程或多进程来实现,也可以将进程分散在多台机器上,worker的数量通常不超过partition的数量,且二者最好保持整数倍关系,因为Kafka在设计时假定了一个partition只能被一个worker消费(同一group内)。

15.Kafka中的消息是否会丢失和重复消费?

要确定Kafka的消息是否丢失或重复,从两个方面分析入手:消息发送和消息消费。

1、消息发送

Kafka消息发送有两种方式:同步(sync)和异步(async),默认是同步方式,可通过producer.type属性进行配置。Kafka通过配置request.required.acks属性来确认消息的生产:

  • 0—表示不进行消息接收是否成功的确认;
  • 1—表示当Leader接收成功时确认;
  • -1—表示Leader和Follower都接收成功时确认;

综上所述,有3种消息生产的情况,下面分情况来分析消息丢失的场景:

(1)acks=0,不和Kafka集群进行消息接收确认,则当网络异常、缓冲区满了等情况时,消息可能丢失;

(2)acks=1、同步模式下,只有Leader确认接收成功后但挂掉了,副本没有同步,数据可能丢失;

2、消息消费

Kafka消息消费有两个consumer接口,Low-level API和High-level API:

Low-level API:消费者自己维护offset等值,可以实现对Kafka的完全控制;

High-level API:封装了对parition和offset的管理,使用简单;

如果使用高级接口High-level API,可能存在一个问题就是当消息消费者从集群中把消息取出来、并提交了新的消息offset值后,还没来得及消费就挂掉了,那么下次再消费时之前没消费成功的消息就“诡异”的消失了;

解决办法:

针对消息丢失:同步模式下,确认机制设置为-1,即让消息写入Leader和Follower之后再确认消息发送成功;异步模式下,为防止缓冲区满,可以在配置文件设置不限制阻塞超时时间,当缓冲区满时让生产者一直处于阻塞状态;

针对消息重复:===看下面一个面试题===

16.如何保证消息不被重复消费?(如何保证消息消费时的幂等性)

首先,比如 RabbitMQ、RocketMQ、Kafka,都有可能会出现消息重复消费的问题,正常。因为这问题通常不是 MQ 自己保证的,是由我们开发来保证的。拿 Kafka 来举个例子,说说怎么重复消费吧。

Kafka 实际上有个 offset 的概念,就是每个消息写进去,都有一个 offset,代表消息的序号,然后 consumer 消费了数据之后,每隔一段时间(定时定期),会把自己消费过的消息的 offset 提交一下,表示“我已经消费过了,下次我要是重启啥的,你就让我继续从上次消费到的 offset 来继续消费吧”。

那出现重复消费的根本原因就是已经消费了数据,但是offset没提交(kafka没有或者不知道该数据已经被消费)。

基于这种原因总结以下几个易造成重复消费的配置:

原因1:强行kill线程,导致消费后的数据,offset没有提交(消费系统宕机、重启等)。

举个例子。

有这么个场景。数据 1/2/3 依次进入 kafka,kafka 会给这三条数据每条分配一个 offset,代表这条数据的序号,分配的 offset 依次是 152/153/154。消费者从 kafka 去消费的时候,也是按照这个顺序去消费。假如当消费者消费了 offset=153 的这条数据,刚准备去提交 offset 到 zookeeper,此时消费者进程被重启了。那么此时消费过的数据 1/2 的 offset 并没有提交,kafka 也就不知道你已经消费了 offset=153 这条数据。那么重启之后,消费者会找 kafka 说,嘿,哥儿们,你给我接着把上次我消费到的那个地方后面的数据继续给我传递过来。数据 1/2 再次被消费。

原因2:设置offset为自动提交,关闭kafka时,如果在close之前,调用 consumer.unsubscribe() 则有可能部分offset没提交,下次重启会重复消费。例如:

上面代码会导致部分offset没提交,下次启动时会重复消费。 

原因3:(重复消费最常见的原因):消费后的数据,当offset还没有提交时,partition就断开连接。比如,通常会遇到消费的数据,处理很耗时,导致超过了Kafka的session timeout时间(0.10.x版本默认是30秒),那么就会re-blance重平衡,此时有一定几率offset没提交,会导致重平衡后重复消费。 

原因4:当消费者重新分配partition的时候,可能出现从头开始消费的情况,导致重发问题。 

原因5:当消费者消费的速度很慢的时候,可能在一个session周期内还未完成,导致心跳机制检测报告出问题。

17.为什么Kafka不支持读写分离?

在 Kafka 中,生产者写入消息、消费者读取消息的操作都是与 leader 副本进行交互的,从 而实现的是一种主写主读的生产消费模型。

Kafka 并不支持主写从读,因为主写从读有 2 个很明 显的缺点:

(1)数据一致性问题。数据从主节点转到从节点必然会有一个延时的时间窗口,这个时间 窗口会导致主从节点之间的数据不一致。某一时刻,在主节点和从节点中 A 数据的值都为 X, 之后将主节点中 A 的值修改为 Y,那么在这个变更通知到从节点之前,应用读取从节点中的 A 数据的值并不为最新的 Y,由此便产生了数据不一致的问题。

(2)延时问题。类似 Redis 这种组件,数据从写入主节点到同步至从节点中的过程需要经 历网络→主节点内存→网络→从节点内存这几个阶段,整个过程会耗费一定的时间。而在 Kafka 中,主从同步会比 Redis 更加耗时,它需要经历网络→主节点内存→主节点磁盘→网络→从节 点内存→从节点磁盘这几个阶段。对延时敏感的应用而言,主写从读的功能并不太适用。

18.Kafka中是怎么体现消息顺序性的?

kafka每个partition中的消息在写入时都是有序的,消费时,每个partition只能被每一个group中的一个消费者消费,保证了消费时也是有序的。

整个topic不保证有序。如果为了保证topic整个有序,那么将partition调整为1。

19.消费者提交消费位移时提交的是当前消费到的最新消息的offset还是offset+1?

offset+1

20.kafka如何实现延迟队列?

Kafka并没有使用JDK自带的Timer或者DelayQueue来实现延迟的功能,而是基于时间轮自定义了一个用于实现延迟功能的定时器(SystemTimer)。JDK的Timer和DelayQueue插入和删除操作的平均时间复杂度为O(nlog(n)),并不能满足Kafka的高性能要求,而基于时间轮可以将插入和删除操作的时间复杂度都降为O(1)。时间轮的应用并非Kafka独有,其应用场景还有很多,在Netty、Akka、Quartz、Zookeeper等组件中都存在时间轮的踪影。

底层使用数组实现,数组中的每个元素可以存放一个TimerTaskList对象。TimerTaskList是一个环形双向链表,在其中的链表项TimerTaskEntry中封装了真正的定时任务TimerTask。

Kafka中到底是怎么推进时间的呢?Kafka中的定时器借助了JDK中的DelayQueue来协助推进时间轮。具体做法是对于每个使用到的TimerTaskList都会加入到DelayQueue中。Kafka中的TimingWheel专门用来执行插入和删除TimerTaskEntry的操作,而DelayQueue专门负责时间推进的任务。再试想一下,DelayQueue中的第一个超时任务列表的expiration为200ms,第二个超时任务为840ms,这里获取DelayQueue的队头只需要O(1)的时间复杂度。如果采用每秒定时推进,那么获取到第一个超时的任务列表时执行的200次推进中有199次属于“空推进”,而获取到第二个超时任务时有需要执行639次“空推进”,这样会无故空耗机器的性能资源,这里采用DelayQueue来辅助以少量空间换时间,从而做到了“精准推进”。Kafka中的定时器真可谓是“知人善用”,用TimingWheel做最擅长的任务添加和删除操作,而用DelayQueue做最擅长的时间推进工作,相辅相成。

21.Kafka中的事务是怎么实现的?

在说Kafka的事务之前,先要说一下Kafka中幂等的实现。幂等和事务是Kafka 0.11.0.0版本引入的两个特性,以此来实现EOS(exactly once semantics,精确一次处理语义)。

幂等,简单地说就是对接口的多次调用所产生的结果和调用一次是一致的。生产者在进行重试的时候有可能会重复写入消息,而使用Kafka的幂等性功能之后就可以避免这种情况。

开启幂等性功能的方式很简单,只需要显式地将生产者客户端参数enable.idempotence设置为true即可(这个参数的默认值为false)。

Kafka是如何具体实现幂等的呢?Kafka为此引入了producer id(以下简称PID)和序列号(sequence number)这两个概念。每个新的生产者实例在初始化的时候都会被分配一个PID,这个PID对用户而言是完全透明的。

对于每个PID,消息发送到的每一个分区都有对应的序列号,这些序列号从0开始单调递增。生产者每发送一条消息就会将对应的序列号的值加1。

broker端会在内存中为每一对维护一个序列号。对于收到的每一条消息,只有当它的序列号的值(SN_new)比broker端中维护的对应的序列号的值(SN_old)大1(即SN_new = SN_old + 1)时,broker才会接收它。

如果SN_new< SN_old + 1,那么说明消息被重复写入,broker可以直接将其丢弃。如果SN_new> SN_old + 1,那么说明中间有数据尚未写入,出现了乱序,暗示可能有消息丢失,这个异常是一个严重的异常。

引入序列号来实现幂等也只是针对每一对而言的,也就是说,Kafka的幂等只能保证单个生产者会话(session)中单分区的幂等。幂等性不能跨多个分区运作,而事务可以弥补这个缺陷。

事务可以保证对多个分区写入操作的原子性。操作的原子性是指多个操作要么全部成功,要么全部失败,不存在部分成功、部分失败的可能。

为了使用事务,应用程序必须提供唯一的transactionalId,这个transactionalId通过客户端参数transactional.id来显式设置。事务要求生产者开启幂等特性,因此通过将transactional.id参数设置为非空从而开启事务特性的同时需要将enable.idempotence设置为true(如果未显式设置,则KafkaProducer默认会将它的值设置为true),如果用户显式地将enable.idempotence设置为false,则会报出ConfigException的异常。

transactionalId与PID一一对应,两者之间所不同的是transactionalId由用户显式设置,而PID是由Kafka内部分配的。

另外,为了保证新的生产者启动后具有相同transactionalId的旧生产者能够立即失效,每个生产者通过transactionalId获取PID的同时,还会获取一个单调递增的producer epoch。如果使用同一个transactionalId开启两个生产者,那么前一个开启的生产者会报错。

从生产者的角度分析,通过事务,Kafka可以保证跨生产者会话的消息幂等发送,以及跨生产者会话的事务恢复。

前者表示具有相同transactionalId的新生产者实例被创建且工作的时候,旧的且拥有相同transactionalId的生产者实例将不再工作。

后者指当某个生产者实例宕机后,新的生产者实例可以保证任何未完成的旧事务要么被提交(Commit),要么被中止(Abort),如此可以使新的生产者实例从一个正常的状态开始工作。

KafkaProducer提供了5个与事务相关的方法,详细如下:

在消费端有一个参数isolation.level,与事务有着莫大的关联,这个参数的默认值为“read_uncommitted”,意思是说消费端应用可以看到(消费到)未提交的事务,当然对于已提交的事务也是可见的。

这个参数还可以设置为“read_committed”,表示消费端应用不可以看到尚未提交的事务内的消息。

举个例子,如果生产者开启事务并向某个分区值发送3条消息msg1、msg2和msg3,在执行commitTransaction()或abortTransaction()方法前,设置为“read_committed”的消费端应用是消费不到这些消息的,不过在KafkaConsumer内部会缓存这些消息,直到生产者执行commitTransaction()方法之后它才能将这些消息推送给消费端应用。反之,如果生产者执行了abortTransaction()方法,那么KafkaConsumer会将这些缓存的消息丢弃而不推送给消费端应用。

日志文件中除了普通的消息,还有一种消息专门用来标志一个事务的结束,它就是控制消息(ControlBatch)。控制消息一共有两种类型:COMMIT和ABORT,分别用来表征事务已经成功提交或已经被成功中止。

RecordBatch中attributes字段的第6位用来标识当前消息是否是控制消息。如果是控制消息,那么这一位会置为1,否则会置为0,如上图所示。

attributes字段中的第5位用来标识当前消息是否处于事务中,如果是事务中的消息,那么这一位置为1,否则置为0。由于控制消息也处于事务中,所以attributes字段的第5位和第6位都被置为1。

KafkaConsumer可以通过这个控制消息来判断对应的事务是被提交了还是被中止了,然后结合参数isolation.level配置的隔离级别来决定是否将相应的消息返回给消费端应用,如上图所示。注意ControlBatch对消费端应用不可见。

22.Kafka中有那些地方需要选举?这些地方的选举策略又有哪些?

Kafka是一个高性能,高容错,多副本,可复制的分布式消息系统。在整个系统中,涉及到多处选举机制,被不少人搞混,这里总结一下,本篇文章大概会从三个方面来讲解。

  • 控制器(Broker)选主
  • 分区多副本选主
  • 消费组选主

控制器(Broker)选举

所谓控制器就是一个Borker,在一个kafka集群中,有多个broker节点,但是它们之间需要选举出一个leader,其他的broker充当follower角色。集群中第一个启动的broker会通过在zookeeper中创建临时节点/controller来让自己成为控制器,其他broker启动时也会在zookeeper中创建临时节点,但是发现节点已经存在,所以它们会收到一个异常,意识到控制器已经存在,那么就会在zookeeper中创建watch对象,便于它们收到控制器变更的通知。

那么如果控制器由于网络原因与zookeeper断开连接或者异常退出,那么其他broker通过watch收到控制器变更的通知,就会去尝试创建临时节点/controller,如果有一个broker创建成功,那么其他broker就会收到创建异常通知,也就意味着集群中已经有了控制器,其他broker只需创建watch对象即可。

如果集群中有一个broker发生异常退出了,那么控制器就会检查这个broker是否有分区的副本leader,如果有那么这个分区就需要一个新的leader,此时控制器就会去遍历其他副本,决定哪一个成为新的leader,同时更新分区的ISR集合。

如果有一个broker加入集群中,那么控制器就会通过Broker ID去判断新加入的broker中是否含有现有分区的副本,如果有,就会从分区副本中去同步数据。

集群中每选举一次控制器,就会通过zookeeper创建一个controller epoch,每一个选举都会创建一个更大,包含最新信息的epoch,如果有broker收到比这个epoch旧的数据,就会忽略它们,kafka也通过这个epoch来防止集群产生“脑裂”。

分区副本选举机制

在kafka的集群中,会存在着多个主题topic,在每一个topic中,又被划分为多个partition,为了防止数据不丢失,每一个partition又有多个副本,在整个集群中,总共有三种副本角色:

  • 首领副本(leader):也就是leader主副本,每个分区都有一个首领副本,为了保证数据一致性,所有的生产者与消费者的请求都会经过该副本来处理。
  • 跟随者副本(follower):除了首领副本外的其他所有副本都是跟随者副本,跟随者副本不处理来自客户端的任何请求,只负责从首领副本同步数据,保证与首领保持一致。如果首领副本发生崩溃,就会从这其中选举出一个leader。
  • 首选首领副本:创建分区时指定的首选首领。如果不指定,则为分区的第一个副本。

follower需要从leader中同步数据,但是由于网络或者其他原因,导致数据阻塞,出现不一致的情况,为了避免这种情况,follower会向leader发送请求信息,这些请求信息中包含了follower需要数据的偏移量offset,而且这些offset是有序的。

如果有follower向leader发送了请求1,接着发送请求2,请求3,那么再发送请求4,这时就意味着follower已经同步了前三条数据,否则不会发送请求4。leader通过跟踪 每一个follower的offset来判断它们的复制进度。

默认的,如果follower与leader之间超过10s内没有发送请求,或者说没有收到请求数据,此时该follower就会被认为“不同步副本”。而持续请求的副本就是“同步副本”,当leader发生故障时,只有“同步副本”才可以被选举为leader。其中的请求超时时间可以通过参数replica.lag.time.max.ms参数来配置。

我们希望每个分区的leader可以分布到不同的broker中,尽可能的达到负载均衡,所以会有一个首选首领,如果我们设置参数auto.leader.rebalance.enable为true,那么它会检查首选首领是否是真正的首领,如果不是,则会触发选举,让首选首领成为首领。

消费组选主

在kafka的消费端,会有一个消费者协调器以及消费组,组协调器GroupCoordinator需要为消费组内的消费者选举出一个消费组的leader,那么如何选举的呢?

如果消费组内还没有leader,那么第一个加入消费组的消费者即为消费组的leader,如果某一个时刻leader消费者由于某些原因退出了消费组,那么就会重新选举leader,如何选举?

上面代码是kafka源码中的部分代码,member是一个hashmap的数据结构,key为消费者的member_id,value是元数据信息,那么它会将leaderId选举为Hashmap中的第一个键值对,它和随机基本没啥区别。

对于整个选举算法的详情需要先了解Raft选举算法,kafka是基于该算法来实现leader选举的。

23.Kafka 与传统消息系统之间有三个关键区别

Kafka 持久化日志,这些日志可以被重复读取和无限期保留
Kafka 是一个分布式系统:它以集群的方式运行,可以灵活伸缩,在内部通过复制数据提升容错能力和高可用性
Kafka 支持实时的流式处理

24.Kafka 创建 Topic 时如何将分区放置到不同的 Broker 中

副本因子不能大于 Broker 的个数,第一个分区(编号为 0)的第一个副本放置位置是随机从 brokerList 选择的,其他分区的第一个副本放置位置相对于第0个分区依次往后移。也就是如果我们有5个 Broker,5个分区,假设第一个分区放在第四个 Broker 上,那么第二个分区将会放在第五个 Broker 上,第三个分区将会放在第一个 Broker 上;第四个分区将会放在第二个 Broker 上,依次类推,剩余的副本相对于第一个副本放置位置其实是由 nextReplicaShift 决定的,而这个数也是随机产生的。

25.Kafka 新建的分区会在哪个目录下创建?

在启动 Kafka 集群之前,我们需要配置好 log.dirs 参数,其值是 Kafka 数据的存放目录,这个参数可以配置多个目录,目录之间使用逗号分隔,通常这些目录是分布在不同的磁盘
上用于提高读写性能。

当然我们也可以配置 log.dir 参数,含义一样。只需要设置其中一个即可。

如果 log.dirs 参数只配置了一个目录,那么分配到各个 Broker 上的分区肯定只能在这个目录下创建文件夹用于存放数据。

但是如果 log.dirs 参数配置了多个目录,那么 Kafka 会在哪个文件夹中创建分区目录呢?

答案是:Kafka 会在含有分区目录最少的文件夹中创建新的分区目录,分区目录名为 Topic 名+分区 ID。注意,是分区文件夹总数最少的目录,而不是磁盘使用量最少的目录!也就是说,如果你给 log.dirs 参数新增了一个新的磁盘,新的分区目录肯定是先在这个新的磁盘上创建直到这个新的磁盘目录拥有的分区目录不是最少为止。

26.partition 的数据如何保存到硬盘

topic 中的多个 partition 以文件夹的形式保存到 broker,每个分区序号从 0 递增,且消息有序 Partition 文件下有多个 segment(xxx.index,xxx.log)segment 文件里的 大小和配置文件大小一致可以根据要求修改 默认为 1g 如果大小大于 1g 时,会滚动一个新的 segment 并且以上一个 segment 最后一条消息的偏移量命名。

27.Kafka 判断一个节点是否还活着有那两个条件?

节点必须可以维护和 ZooKeeper 的连接,Zookeeper 通过心跳机制检查每个节点的连接
如果节点是个 follower,他必须能及时的同步 leader 的写操作,延时不能太久

0

Spring Cloud学习书籍推荐

一、《Spring Cloud微服务实战》

《Spring Cloud微服务实战》从时下流行的微服务架构概念出发,详细介绍了Spring Cloud针对微服务架构中几大核心要素的解决方案和基础组件。对于各个组件的介绍,《Spring Cloud微服务实战》主要以示例与源码结合的方式来帮助读者更好地理解这些组件的使用方法以及运行原理。同时,在介绍的过程中,还包含了作者在实践中所遇到的一些问题和解决思路,可供读者在实践中作为参考。

二、《Spring Cloud与Docker微服务架构实战(第2版)》

本书基于Spring Cloud Edgware RELEASE 与Docker 17.09,以指导技术团队实现微服务架构落地为宗旨,覆盖微服务理论、微服务开发框架(Spring Cloud)及运行平台(Docker)三大主题。全书分为3部分,第1部分对微服务架构进行系统介绍;第2部分使用Spring Cloud 开发框架编写一个“电影售票系统”;第3部分讲解如何将微服务应用运行在Docker 之上。全书采用精心设计的Demo 驱动,以连贯的场景、真实的代码示例来引导读者学习用强大的微服务技术实现架构设计。作为第2版,本书增补大量新版本框架独有的技术特性及其技巧、用例,以帮助读者避开升级中可能遇到的困难与陷阱。

三、《深入理解Spring Cloud与微服务构建 第2版》

《深入理解Spring Cloud与微服务构建 第2版》共分为18章,全面涵盖了通过Spring Cloud构建微服务的相关知识点。第1、2章详细介绍了微服务架构和Spring Cloud。第3、4章讲解了通过Spring Cloud构建微服务的准备工作。第5~14章以案例为切入点,讲解了通过Spring Cloud构建微服务的基础组件,包括Eureka、Ribbon、Feign、Hystrix、Zuul、Gateway、Consul、Config、Sleuth、Admint等组件。第15~17章讲述了使用Spring Cloud OAuth2来保护微服务系统的相关知识。第18章用一个综合案例全面讲解了如何使用Spring Cloud构建微服务,可用于实际开发中。

四、《Spring Cloud微服务:入门、实战与进阶》

这是一部从技术原理、工程实践和进阶提升3个维度讲解Spring Cloud微服务架构与开发的著作。作者在Spring Cloud微服务领域有丰富的工程实践经验,它将带领读者零基础入门Spring Cloud微服务,并快速掌握动手实践能力,*终进阶为Spring Cloud微服务领域的技术达人。

本书很好地将微服务中的重要话题Spring Cloud与其他开源组件融合起来,这其中也包括了Elastic-Job和Sharding-JDBC。作为这两款开源产品的作者之一,我很高兴地看到它们已逐渐走进技术人员的视野中。希望读者阅读本书后,可以快速熟悉当今微服务技术栈的整体结构,并提升技术选型的能力。

五、《Spring Cloud微服务架构开发实战》

本书首先从微服务架构兴起的背景讲起,探讨了为何在分布式系统开发中微服务架构将逐渐取代单体架构;然后对Spring Cloud所提供的微服务组件及解决方案进行了一一讲解,从而让读者不但可以系统地学习Spring Cloud的相关知识,而且还可以全面掌握微服务架构应用的设计、开发、部署和运维等知识。

六、《重新定义Spring Cloud实战》

这是一本实践与理论并重、广度与深度兼顾的Spring Cloud生产实践开发指南,由Spring Cloud中国社区倾力打造,作者来自阿里、蚂蚁金服、京东金融等企业,本书针对Spring Cloud在国内的使用情况,结合国内企业使用Spring Cloud落地微服务架构遇到的问题,提出可落地的解决方案。

本书内容有3大特色:

足够广:详细讲解了Spring Cloud的核心常用组件以及Spring Cloud的增强生态,针对生产实践中常见问题给出可落地的最佳实践方案,无论您是初学者还是开发人员,还是架构师,都能从此书获益。

有深度:本书对涉及的Spring Cloud组件按照从入门、进阶、实战、扩展增强的顺序循序渐进进行剖析和讲解,帮助作者知其然并知其所以然,授之以渔。

重实践:注重生产实践,通过案例驱动,给出优秀的生产实践方案和优秀的生产配置,帮助读者快速落地企业微服务架构。

七、《Spring Cloud微服务:全栈技术与案例解析》

本书内容共18章,共分为4个部分。第1部分为准备篇,准备篇当中会对微服务以及SpringCloud做一个整体的介绍,同时将SpringCloud的基础内容进行讲解,比如SpringBoot。第2部分为基础篇,基础篇当中会对SpringCloud的几大常用模块进行讲解和简单使用。第3部分为实战篇,实战篇当中会通过对在微服务架构中普遍遇到的问题进行实战解决讲解。第4部分为高级篇,高级篇当中就是对SpringCloud进行一些扩展性的使用,比如API网关怎么限流,怎么做灰度发布等。

八、《疯狂Spring Cloud微服务架构实战》

本书以Spring Cloud为基础,深入讲解微服务开发的相关框架,包括服务管理框架Eureka、负载均衡框架Ribbon、服务客户端Feign、容错框架Hystrix、消息框架Stream等。除了介绍这些微服务相关的框架外,在本书的第11章,还介绍了如何使用Spring Data框架操作各个主流数据库(MySQL、MongoDB、Redis)。在第12章,以一个案例为基础结束本书内容,在该章中讲解了模板引擎Thymeleaf,整本书将会为大家提供一整套微服务应用开发的解决方案。本书适合有一定Java开发基础的技术人员,尤其是正在使用或准备使用微服务构建高并发、大数据应用的技术人员及团队。

九、《Spring Cloud微服务架构进阶》

本书重点介绍微服务架构的Spring Cloud框架,在实践的基础上进行用法的拓展与相关组件的源码分析,包括:服务发现、负载均衡、断路、声明式HTTP调用客户端、网关、分布式配置中心、安全权限、消息总线等组件。本书适合Java开发人员,特别适合正在进行微服务化改造的开发人员、架构师,在改造过程中进行参考与进阶应用。

十、《Spring Cloud实战》

本书以Spring Cloud微服务架构为主线,依次通过案例讲述Spring Cloud的常用组件。看完本书后,大家会比较熟悉基于 Spring Cloud微服务架构的开发技术。

本书内容包括Spring Boot微服务入门、Spring Data连接数据库、Eureka服务治理框架、Ribbon负载均衡组件、HyStrix服务容错组件、Feign服务调用框架、Zuul网关组件、用Spring Cloud Config搭建配置中心、消息机制与消息驱动框架、微服务健康检查与服务跟踪, 后给出一个SpringBoot开发Web的实战案例。

0

高级Java深入学习JVM书籍推荐

一、《深入理解Java虚拟机——JVM高级特性与最佳实践(第2版)》

基于最新JDK1.7,围绕内存管理、执行子系统、程序编译与优化、高效并发等核心主题对JVM进行全面而深入的分析,深刻揭示JVM的工作原理。以实践为导向,通过大量与实际生产环境相结合的案例展示了解决各种常见JVM问题的技巧和实践。

二、《揭秘Java虚拟机:JVM设计原理与实现》

《揭秘Java虚拟机:JVM设计原理与实现》从源码角度解读HotSpot的内部实现机制,主要包含三大部分——JVM数据结构设计与实现、执行引擎机制及内存分配模型。数据结构部分包括Java字节码文件格式、常量池解析、字段解析、方法解析。每一部分都给出详细的源码实现分析,例如字段解析一章,从源码层面详细分析了Java字段重排、字段继承等关键机制。

三、《Java虚拟机规范》(Java SE 8版)

本书由该技术的创立人所写,是权威的Java虚拟机参考资料。书中完备、准确而又详尽地描述了Java虚拟机。它完整地讲述了由JavaSE8所引入的新特性,例如对包含默认实现代码的接口方法所做的调用,以及为支持类型注解及方法参数注解而对class文件格式所做的扩展。此书也阐明了class文件中各属性的含义,以及字节码验证的规则。

四、《实战Java虚拟机:JVM故障诊断与性能优化》

《实战Java虚拟机——JVM故障诊断与性能优化》内容简介:随着越来越多的第三方语言(Groovy、Scala、JRuby等)在Java虚拟机上运行,Java也俨然成为一个充满活力的生态圈。本书将通过200余示例详细介绍Java虚拟机中的各种参数配置、故障排查、性能监控以及性能优化。

五、《HotSpot实战》

《HotSpot实战》深入浅出地讲解了HotSpot虚拟机的工作原理,将隐藏在它内部的本质内容逐一呈现在读者面前,包括OpenJDK与HotSpot项目、编译和调试HotSpot的方法、HotSpot内核结构、Launcher、OOP-Klass对象表示系统、链接、运行时数据区、方法区、常量池和常量池Cache、Perf Data、Crash分析方法、转储分析方法、垃圾收集器的设计演进、CMS和G1收集器、栈、JVM对硬件寄存器的利用、栈顶缓存技术、解释器、字节码表、转发表、Stubs、Code Cache、Code生成器、JIT编译器、C1编译器、编译原理、JVM指令集实现、函数的分发机制、VTABLE和ITABLE、异常表、虚拟机监控工具(如jinfo、jstack、jhat、jmap等)的实现原理和开发方法、Attach机制、基于GUI的JVM分析工具(如MAT、VisualVM)等内容。

六、《深入理解JVM & G1 GC》

本书主要为学习Java语言的学生、初级程序员提供GC的使用参考建议及经验,着重介绍了G1 GC。

七、《垃圾回收的算法与实现》

本书分为“算法篇”和“实现篇”两大部分。算法篇介绍了标记-清除算法、引用计数法、复制算法、标记-压缩算法、保守式GC、分代垃圾回收、增量式垃圾回收、RC Immix算法等几种重要的算法;实现篇介绍了垃圾回收在Python、DalvikVM、Rubinius、V8等几种语言处理程序中的具体实现。

八、《Java虚拟机精讲》

HotSpot VM 是目前市面上高性能JVM 的代表作之一,它采用解释器+JIT 编译器的混合执行引擎,使得Java 程序的执行性能从此有了质的飞跃。本书以极其精练的语句诠释了HotSpot VM 的方方面面,比如:字节码的编译原理、字节码的内部组成结构、通过源码的方式剖析HotSpot VM 的启动过程和初始化过程、Java 虚拟机的运行时内存、垃圾收集算法、垃圾收集器(重点讲解了Serial 收集器、ParNew 收集器、Parallel 收集器、CMS(Concurrent-Mark-Sweep)收集器和G1(Garbage-First)收集器)、类加载机制,以及HotSpot VM 基于栈的架构模型和执行引擎(解释器的工作流程、JIT 编译器的工作流程、分层编译策略、热点探测功能)等技术。

九、《虚拟机设计与实现 以JVM为例》

本书从一位虚拟机(VM)架构师的角度,以易于理解、层层深入的方式介绍了各种主题和算法,尤其是不同VM通用的主要技术。这些算法用图示充分解释,用便于理解的代码片段实现,使得这些抽象概念对系统软件工程师而言具像化并可编程。书中还包括一些同类文献中较少涉及的主题,例如运行时辅助、栈展开和本地接口。本书集理论性与实践性于一身,不仅结合了高层设计功能与底层实现,而且还结合了*级主题与商业解决方案,是VM设计和工程实践方面的理想参考读物。

0

dalvik和Jvm的区别

一、Dalvik简述

在Android的体系框架中有一部分叫做Android Runtime,即Android运行时环境,Android Runtime环境包括了两个部分,第一部门是Android的核心类库,第二部分是Dalvik虚拟机。

Dalvik虚拟机对内存具有高效的使用,以及在低速CPU上运行具有高性能。依赖于底层Posix兼容的操作系统,它可以简单的完成进程隔离和线程管理。每一个Android应用在底层都会对应一个独立的Dalvik虚拟机实例, 其代码在虚拟机的解释下得以执行。Dalvik虚拟机并不是按照Java虚拟机的规范来实现的,两者并不兼容。

二、Dalvik和Jvm区别

Dalvik虚拟机运行的专有的文件格式Dex(Dalvik Executable)文件。Android应用虽然也是使用Java语言进行编程,但是在编译成class文件后,还会通过一个工具(dx)将应用所有的 class文件转换成一个Dex文件,而后Dalvik虚拟机会从其中读取指令和数据。Dalvik虚拟机运行的是其专有的文件格式Dex,Dex文件格式可以减少整体文件尺寸,提高I/o操作的类查找速度。所有的Android应用的线程都对应一个Linux线程,虚拟机因此可以更多的依赖操作系统的线程调度和管理机制。

Java虚拟机运行java字节码。在Java SE程序中的Java类会被编译成一个或者多个字节码文件(.class)然后打包到jar文件,而后Java虚拟机会从相应的class文件和jar文件中获取相应的字节码

1.架构设计

Dalvik基于寄存器。寄存器是在cpu上的一块存储空间,cpu如果直接从寄存器上读取数据的话就会快很多。
JVM基于栈。所以每次访问数据cpu都要到内存中取到数据。

2.运行效率

Dalvik是基于寄存器效率高于基于栈的JVM。

3.编写语言

Dalvik是由C或C++编写,JVM是由C++或java编写。

4.运行环境

Dalvik在有限的内存,允许同时运行多个Dalvik实例,并且每一个Dalvik应用作为一个独立的Linux进程执行。
JVM在有限的内存只能运行一个JVM实例,JVM因平台的不一样进程也不一样。

5.运行格式

Jvm一般是.class。jvm是把.java文本编译成.class字节码文件,在执行java程序的时候,类加载器把需要的类全部加载到内存当中去。
Dalvik是.dex 把.java文件编译成.class文件,又把.class文件转换成.dex文件,dalvik来执行.dex文件。

6.函数加载

Dalvik是Dexfile加载class类文件,JVM和KVM是ClassLoader。

7.版权归属

Dalvik归属google。
Jvm归属甲骨文。

0