Welcome to yuippe's blog

• Github Ssh Configuration

  2020-04-14

  window下SSH密钥配置

  每次向GitHub签入代码时，都要输入用户名和密码，非常麻烦。可以通过使用SSH避免每次提交都需要输入账号和密码

  第一步 查看是否已经存在SSH秘钥(keys)

  右键打开 Git Bash ,并运行：

  $ cd ~/.ssh
  

  如果提示如下信息为 No such file or directory，则说明不存在SSH秘钥，如果已经存在，可以直接进入第三步。

  $ cd ~/.ssh
  
  sh.exe": cd: /c/Users/Xue/.ssh: No such file or directory
  

  如果无提示信息，进入 .ssh 目录执行 ls 命令，可查看本机已经存在的SSH的公钥和私钥。

  第二步 创建新的SSH密钥(keys)

  输入如下命令：

  $ cd ~   		# 保证当前路径在 `~` 下，即 `C:/Users/用户名` 目录pwd
  $ ssh-keygen -t rsa -C "your_email@example.com"   # 这将根据你提供的邮箱地址，创建一对密钥
  

  提示信息如下：

  $ ssh-keygen -t rsa -C "your_email@example.com"
  Generating public/private rsa key pair.
  Enter file in which to save the key (/c/Users/用户名/.ssh/id_rsa):   # 直接回车，则将密钥按默认路径及文件名进行存储。此时也可以输入特定的文件名
  Created directory '/c/Users/用户名/.ssh'.
  Enter passphrase (empty for no passphrase):   # 根据提示，你需要输入密码和确认密码。可以不填，设置为空值，直接回车
  Enter same passphrase again:
  Your identification has been saved in /c/Users/用户名/.ssh/id_rsa.
  Your public key has been saved in /c/Users/用户名/.ssh/id_rsa.pub.
  The key fingerprint is:
  6d:40:da:xx:xx:xx:xx:b8:60:4a:bd:61:5f:c5:d6:db your_email@example.com
  The key's randomart image is:
  +--[ RSA 2048]----+
  |   .   .=oo.     |
  |  . * .=.*o .    |
  | . + =oo+..  o   |
  |  . ..o. o  . E  |
  |      . S o      |
  |         .       |
  |                 |
  |                 |
  |                 |
  +-----------------+
  

  然后在目录 ~/.ssh 下，就新创建了两个文件：

  $ cd ~/.ssh
  $ ls
  id_rsa  id_rsa.pub
  

  第三步 在GitHub账户中添加你的公钥

  执行如下命令，将公钥的内容复制到系统剪切板中(或直接打开该文件进行复制操作)：

  clip < ~/.ssh/id_rsa.pub
  

  登陆Github网站，选择 Settings –> SSH and GPG keys 菜单，点击 New SSH key 按钮。 粘贴你的密钥到 Key 输入框中并设置 Title 信息，点击 Add SSH key 按钮完成。

  至此，添加完毕。

  第四步 连接测试

  先保证本地 Git 已设置好git账户的 用户名 和 邮箱 信息：

  $ git config --global user.name "your_username"   # 设置用户名
  $ git config --global user.email "your_email@example.com"  # 设置邮箱地址
  

  测试SSH keys 是否设置成功，执行如下命令：

  $ ssh -T git@github.com
  

  提示信息如下：

  $ ssh -T git@github.com
  The authenticity of host 'github.com (192.30.253.113)' can't be established.
  RSA key fingerprint is 16:27:xx:xx:xx:xx:xx:36:63:1b:56:4d:eb:df:a6:48.
  Are you sure you want to continue connecting (yes/no)? yes  # 确认你是否继续连接，输入yes
  Warning: Permanently added 'github.com,192.30.253.113' (RSA) to the list of know
  n hosts.
  Hi xxx! You've successfully authenticated, but GitHub does not provide shell
   access.  #  出现这句话，说明设置成功
  

  当提示如下信息，说明连通Github成功：

  Hi xxx! You've successfully authenticated, but GitHub does not provide shell
   access.
  
  

  第五步 将本地项目通过 SSH push 到 GitHub

  在github新建一个仓库，如 test_ssh 。

  执行以下命令：

  ## 创建目录
  $ mkdir test
  $ cd test
  ## 初始化git仓库
  $ git init
  ## 创建readme.md文件
  $ echo "this is a test ssh keys" > README.md
  ## 提交到本地
  ## 提交当前目录下的所有文件
  $ git add .
  ## 提交记录说明
  $ git commit -m "add readme.md"
  ## 提交到github
  $ git remote add origin git@github.com:your_github_name/test_ssh.git
  $ git push -u origin master
  

  刷新 test_ssh 仓库，就能看到提交的文件了。

  如果是本地已经存在的git项目，只需要执行以下命令即可：

  ## 提交到github
  $ git remote add origin git@github.com:your_github_name/test_ssh.git
  $ git push -u origin master
  

  Read All

  ---

• springboot interview question

  2018-10-23

  yuippe

  question

  springboot  question
  • question
  • SpringFrame
  • SpringMVC
  • SpringBoot
    • 方法 1：关闭安全验证
    • 方法二：在日志中搜索密码并传递至请求标头中
    • POST
      • 第一步 - 把 mysql 连接器的依赖项添加至 pom.xml
      • 第二步 - 从 pom.xml 中移除 H2 的依赖项
      • 第三步 - 安装你的 MySQL 数据库
      • 第四步 - 配置你的 MySQL 数据库连接
      • 第五步 - 重新启动，你就准备好了！

  question

  问题一 Spring Boot、Spring MVC 和 Spring 有什么区别？

  SpringFrame

  SpringFramework 最重要的特征是依赖注入。所有 SpringModules 不是依赖注入就是 IOC 控制反转。

  当我们恰当的使用 DI 或者是 IOC 的时候，我们可以开发松耦合应用。松耦合应用的单元测试可以很容易的进行。

  SpringMVC

  Spring MVC 提供了一种分离式的方法来开发 Web 应用。通过运用像 DispatcherServelet，MoudlAndView 和 ViewResolver 等一些简单的概念，开发 Web 应用将会变的非常简单。

  SpringBoot

  Spring 和 SpringMVC 的问题在于需要配置大量的参数。

  <bean
   class="org.springframework.web.servlet.view.InternalResourceViewResolver">
  <property name="prefix">
          <value>/WEB-INF/views/</value>
      </property>
      <property name="suffix">
          <value>.jsp</value>
      </property>
    </bean>
  
    <mvc:resources mapping="/webjars/**" location="/webjars/"/>
  

  Spring Boot 通过一个自动配置和启动的项来目解决这个问题。为了更快的构建产品就绪应用程序，Spring Boot 提供了一些非功能性特征。

  ##

  问题二 什么是自动配置？

  Spring 和 SpringMVC 的问题在于需要配置大量的参数。

  <bean
   class="org.springframework.web.servlet.view.InternalResourceViewResolver">
  <property name="prefix">
          <value>/WEB-INF/views/</value>
      </property>
      <property name="suffix">
          <value>.jsp</value>
      </property>
    </bean>
  
    <mvc:resources mapping="/webjars/**" location="/webjars/"/>
  

  我们能否带来更多的智能？当一个 MVC JAR 添加到应用程序中的时候，我们能否自动配置一些 beans？

  Spring 查看（CLASSPATH 上可用的框架）已存在的应用程序的配置。在此基础上，Spring Boot 提供了配置应用程序和框架所需要的基本配置。这就是自动配置。

  ##

  问题三 什么是 Spring Boot Stater ？

  启动器是一套方便的依赖没描述符，它可以放在自己的程序中。你可以一站式的获取你所需要的 Spring 和相关技术，而不需要依赖描述符的通过示例代码搜索和复制黏贴的负载。

  例如，如果你想使用 Sping 和 JPA 访问数据库，只需要你的项目包含 spring-boot-starter-data-jpa 依赖项，你就可以完美进行。

  问题四 你能否举一个例子来解释更多 Staters 的内容？

  让我们来思考一个 Stater 的例子 -Spring Boot Stater Web。

  如果你想开发一个 web 应用程序或者是公开 REST 服务的应用程序。Spring Boot Start Web 是首选。让我们使用 Spring Initializr 创建一个 Spring Boot Start Web 的快速项目。

  Spring Boot Start Web 的依赖项

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

  下面的截图是添加进我们应用程序的不同的依赖项

  

  依赖项可以被分为

  Spring - core，beans，context，aop

  Web MVC - （Spring MVC）

  Jackson - for JSON Binding

  Validation - Hibernate,Validation API

  Enbedded Servlet Container - Tomcat

  Logging - logback,slf4j

  任何经典的 Web 应用程序都会使用所有这些依赖项。Spring Boot Starter Web 预先打包了这些依赖项。

  作为一个开发者，我不需要再担心这些依赖项和它们的兼容版本。

  ##

  问题五 Spring Boot 还提供了其它的哪些 Starter Project Options？

  Spring Boot 也提供了其它的启动器项目包括，包括用于开发特定类型应用程序的典型依赖项。

  spring-boot-starter-web-services - SOAP Web Services

  spring-boot-starter-web - Web 和 RESTful 应用程序

  spring-boot-starter-test - 单元测试和集成测试

  spring-boot-starter-jdbc - 传统的 JDBC

  spring-boot-starter-hateoas - 为服务添加 HATEOAS 功能

  spring-boot-starter-security - 使用 SpringSecurity 进行身份验证和授权

  spring-boot-starter-data-jpa - 带有 Hibeernate 的 Spring Data JPA

  spring-boot-starter-data-rest - 使用 Spring Data REST 公布简单的 REST 服务

  ##

  问题六 Spring 是如何快速创建产品就绪应用程序的？

  Spring Boot 致力于快速产品就绪应用程序。为此，它提供了一些譬如高速缓存，日志记录，监控和嵌入式服务器等开箱即用的非功能性特征。

  spring-boot-starter-actuator - 使用一些如监控和跟踪应用的高级功能

  spring-boot-starter-undertow, spring-boot-starter-jetty, spring-boot-starter-tomcat - 选择您的特定嵌入式 Servlet 容器

  spring-boot-starter-logging - 使用 logback 进行日志记录

  spring-boot-starter-cache - 启用 Spring Framework 的缓存支持

  ###Spring2 和 Spring5 所需要的最低 Java 版本是什么？

  Spring Boot 2.0 需要 Java8 或者更新的版本。Java6 和 Java7 已经不再支持。

  推荐阅读：

  https://github.com/spring-projects/spring-boot/wiki/Spring-Boot-2.0.0-M1-Release-Notes

  ##

  问题七 创建一个 Spring Boot Project 的最简单的方法是什么？

  Spring Initializr是启动 Spring Boot Projects 的一个很好的工具。

  

  • 就像上图中所展示的一样，我们需要做一下几步：
  • 登录 Spring Initializr，按照以下方式进行选择：
  • 选择 com.in28minutes.springboot 为组
  • 选择 studet-services 为组件
  • 选择下面的依赖项
  • Web
  • Actuator
  • DevTools
  • 点击生 GenerateProject
  • 将项目导入 Eclipse。文件 - 导入 - 现有的 Maven 项目

  ##

  问题八 Spring Initializr 是创建 Spring Boot Projects 的唯一方法吗？

  不是的。

  Spring Initiatlizr 让创建 Spring Boot 项目变的很容易，但是，你也可以通过设置一个 maven 项目并添加正确的依赖项来开始一个项目。

  在我们的 Spring 课程中，我们使用两种方法来创建项目。

  第一种方法是 start.spring.io 。 另外一种方法是在项目的标题为“Basic Web Application”处进行手动设置。

  手动设置一个 maven 项目

  这里有几个重要的步骤：

  • 在 Eclipse 中，使用文件 - 新建 Maven 项目来创建一个新项目
  • 添加依赖项。
  • 添加 maven 插件。
  • 添加 Spring Boot 应用程序类。

  到这里，准备工作已经做好！

  ##

  问题九 为什么我们需要 spring-boot-maven-plugin?

  spring-boot-maven-plugin 提供了一些像 jar 一样打包或者运行应用程序的命令。

  • spring-boot:run 运行你的 SpringBooty 应用程序。
  • spring-boot：repackage 重新打包你的 jar 包或者是 war 包使其可执行
  • spring-boot：start 和 spring-boot：stop 管理 Spring Boot 应用程序的生命周期（也可以说是为了集成测试）。
  • spring-boot:build-info 生成执行器可以使用的构造信息。

  ##

  问题十 如何使用 SpringBoot 自动重装我的应用程序？

  使用 Spring Boot 开发工具。

  把 Spring Boot 开发工具添加进入你的项目是简单的。

  把下面的依赖项添加至你的 Spring Boot Project pom.xml 中

  <dependency>
       <groupId>org.springframework.boot</groupId>
       <artifactId>spring-boot-devtools</artifactId>
       <scope>runtime</scope>
  </dependency>
  

  重启应用程序，然后就可以了。

  同样的，如果你想自动装载页面，有可以看看 FiveReload

  • http://www.logicbig.com/tutorials/spring-framework/spring-boot/boot-live-reload/.

  在我测试的时候，发现了 LiveReload 漏洞，如果你测试时也发现了，请一定要告诉我们。

  ##

  问题十一 什么是嵌入式服务器？我们为什么要使用嵌入式服务器呢?

  思考一下在你的虚拟机上部署应用程序需要些什么。

  第一步： 安装 Java

  第二部： 安装 Web 或者是应用程序的服务器（Tomat/Wbesphere/Weblogic 等等）

  第三部： 部署应用程序 war 包

  如果我们想简化这些步骤，应该如何做呢？

  让我们来思考如何使服务器成为应用程序的一部分？

  你只需要一个安装了 Java 的虚拟机，就可以直接在上面部署应用程序了， 是不是很爽？

  这个想法是嵌入式服务器的起源。

  当我们创建一个可以部署的应用程序的时候，我们将会把服务器（例如，tomcat）嵌入到可部署的服务器中。

  例如，对于一个 Spring Boot 应用程序来说，你可以生成一个包含 Embedded Tomcat 的应用程序 jar。你就可以想运行正常 Java 应用程序一样来运行 web 应用程序了。

  嵌入式服务器就是我们的可执行单元包含服务器的二进制文件（例如，tomcat.jar）。

  ##

  问题十二 如何在 Spring Boot 中添加通用的 JS 代码？

  在源文件夹下，创建一个名为 static 的文件夹。然后，你可以把你的静态的内容放在这里面。

  例如，myapp.js 的路径是 resources\static\js\myapp.js

  你可以参考它在 jsp 中的使用方法

  <csript src="/js/myapp.js"></script>
  

  错误：HAL browser gives me unauthorized error - Full authenticaition is required to access this resource.

  该如何来修复这个错误呢？

  {
    "timestamp": 1488656019562,
    "status": 401,
    "error": "Unauthorized",
    "message": "Full authentication is required to access this resource.",
    "path": "/beans"
  }
  

  两种方法：

  方法 1：关闭安全验证

  application.properties

  management.security.enabled:FALSE
  

  方法二：在日志中搜索密码并传递至请求标头中

  ##

  问题十三 什么是 Spring Date？

  来自：//projects.spring.io/spring- data/

  Spring Data 的使命是在保证底层数据存储特殊性的前提下，为数据访问提供一个熟悉的，一致性的，基于 Spring 的编程模型。这使得使用数据访问技术，关系数据库和非关系数据库，map-reduce 框架以及基于云的数据服务变得很容易。

  为了让它更简单一些，Spring Data 提供了不受底层数据源限制的 Abstractions 接口。

  下面来举一个例子

  interface TodoRepository extends CrudRepository<Todo, Long> {
  

  你可以定义一简单的库，用来插入，更新，删除和检索代办事项，而不需要编写大量的代码。

  ##

  问题十四 什么是 Spring Data REST?

  Spring Data TEST 可以用来发布关于 Spring 数据库的 HATEOAS RESTful 资源。

  下面是一个使用 JPA 的例子

  @RepositoryRestResource(collectionResourceRel = "todos", path = "todos")
  public interface TodoRepository
          extends PagingAndSortingRepository<Todo, Long> {
  

  不需要写太多代码，我们可以发布关于 Spring 数据库的 RESTful API。

  下面展示的是一些关于 TEST 服务器的例子

  POST

  • URL:http：//localhost：8080/todos
  • Use Header:Content-Type:Type:application/json
  • Request Content

  代码如下

  {
    "user": "Jill",
    "desc": "Learn Hibernate",
    "done": false
  }
  

  响应内容

  {
    "user": "Jill",
    "desc": "Learn Hibernate",
    "done": false,
    "_links": {
  "self": {
    "href": "http://localhost:8080/todos/1"
  },
  "todo": {
    "href": "http://localhost:8080/todos/1"
  }
    }
  }
  

  响应包含新创建资源的 href。

  ##

  问题十五 path=”users”, collectionResourceRel=”users” 如何与 Spring Data Rest 一起使用？

  @RepositoryRestResource(collectionResourceRel = "users", path = "users")
  
  public interface UserRestRepository extends
  PagingAndSortingRepository<User, Long> 
  

  • path- 这个资源要导出的路径段。
  • collectionResourceRel- 生成指向集合资源的链接时使用的 rel 值。在生成 HATEOAS 链接时使用。

  ##

  问题十六 当 Spring Boot 应用程序作为 Java 应用程序运行时，后台会发生什么？

  如果你使用 Eclipse IDE，Eclipse maven 插件确保依赖项或者类文件的改变一经添加，就会被编译并在目标文件中准备好！在这之后，就和其它的 Java 应用程序一样了。

  当你启动 java 应用程序的时候，spring boot 自动配置文件就会魔法般的启用了。

  • 当 Spring Boot 应用程序检测到你正在开发一个 web 应用程序的时候，它就会启动 tomcat。

  ##

  问题十七 我们能否在 spring-boot-starter-web 中用 jetty 代替 tomcat？

  在 spring-boot-starter-web 移除现有的依赖项，并把下面这些添加进去。

  <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-web</artifactId>
      <exclusions>
          <exclusion>
              <groupId>org.springframework.boot</groupId>
              <artifactId>spring-boot-starter-tomcat</artifactId>
          </exclusion>
      </exclusions>
  </dependency>
  <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-jetty</artifactId>
  </dependency>
  

  问题十八 如何使用 Spring Boot 生成一个 WAR 文件？

  推荐阅读:

  • https://spring.io/guides/gs/convert-jar-to-war/

  下面有 spring 说明文档直接的链接地址：

  • https://docs.spring.io/spring-boot/docs/current/reference/htmlsingle/#build-tool-plugins-maven-packaging

  ##

  问题十九 如何使用 Spring Boot 部署到不同的服务器？

  你需要做下面两个步骤：

  • 在一个项目中生成一个 war 文件。
  • 将它部署到你最喜欢的服务器（websphere 或者 Weblogic 或者 Tomcat and so on）。

  第一步：这本入门指南应该有所帮助： https://spring.io/guides/gs/convert-jar-to-war/

  第二步：取决于你的服务器。

  ##

  问题二十 RequestMapping 和 GetMapping 的不同之处在哪里？

  • RequestMapping 具有类属性的，可以进行 GET,POST,PUT 或者其它的注释中具有的请求方法。
  • GetMapping 是 GET 请求方法中的一个特例。它只是 ResquestMapping 的一个延伸，目的是为了提高清晰度。

  ##

  问题二十一 为什么我们不建议在实际的应用程序中使用 Spring Data Rest?

  我们认为 Spring Data Rest 很适合快速原型制造！在大型应用程序中使用需要谨慎。

  通过 Spring Data REST 你可以把你的数据实体作为 RESTful 服务直接发布。

  当你设计 RESTful 服务器的时候，最佳实践表明，你的接口应该考虑到两件重要的事情：

  • 你的模型范围。
  • 你的客户。

  通过 With Spring Data REST，你不需要再考虑这两个方面，只需要作为 TEST 服务发布实体。

  这就是为什么我们建议使用 Spring Data Rest 在快速原型构造上面，或者作为项目的初始解决方法。对于完整演变项目来说，这并不是一个好的注意。

  ##

  问题二十二 在 Spring Initializer 中，如何改变一个项目的包名字？

  好消息是你可以定制它。点击链接“转到完整版本”。你可以配置你想要修改的包名称！

  ##

  问题二十三 可以配置 application.propertierde 的完整的属性列表在哪里可以找到？

  这里是完整的指南：

  • https://docs.spring.io/spring-boot/docs/current/reference/html/common-application-properties.html

  ##

  问题二十四 JPA 和 Hibernate 有哪些区别？

  简而言之

  • JPA 是一个规范或者接口
  • Hibernate 是 JPA 的一个实现

  当我们使用 JPA 的时候，我们使用 javax.persistence 包中的注释和接口时，不需要使用 hibernate 的导入包。

  我们建议使用 JPA 注释，因为哦我们没有将其绑定到 Hibernate 作为实现。后来（我知道 - 小于百分之一的几率），我们可以使用另一种 JPA 实现。

  ##

  问题二十五 业务边界应该从哪一层开始？

  我们建议在服务层管理义务。商业业务逻辑在商业层或者服务层，与此同时，你想要执行的业务管理也在该层。

  ##

  问题二十六 使用 Spring Boot 启动连接到内存数据库 H2 的 JPA 应用程序需要哪些依赖项？

  在 Spring Boot 项目中，当你确保下面的依赖项都在类路里面的时候，你可以加载 H2 控制台。

  • web 启动器
  • h2
  • jpa 数据启动器

  其它的依赖项在下面：

  <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-web</artifactId>
  </dependency>
  
  <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-data-jpa</artifactId>
  </dependency>
  
  <dependency>
      <groupId>com.h2database</groupId>
      <artifactId>h2</artifactId>
      <scope>runtime</scope>
  </dependency>
  

  需要注意的一些地方：

  • 一个内部数据内存只在应用程序执行期间存在。这是学习框架的有效方式。
  • 这不是你希望的真是世界应用程序的方式。
  • 在问题“如何连接一个外部数据库？”中，我们解释了如何连接一个你所选择的数据库。

  ##

  问题二十七 如何不通过任何配置来选择 Hibernate 作为 JPA 的默认实现？

  因为 Spring Boot 是自动配置的。

  下面是我们添加的依赖项

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

  spring-boot-stater-data-jpa 对于 Hibernate 和 JPA 有过渡依赖性。

  当 Spring Boot 在类路径中检测到 Hibernate 中，将会自动配置它为默认的 JPA 实现。

  ##

  问题二十八 指定的数据库连接信息在哪里？它是如何知道自动连接至 H2 的？

  这就是 Spring Boot 自动配置的魔力。

  来自：https://docs.spring.io/spring-boot/docs/current/reference/html/using-boot-auto-configuration.html

  Spring Boot auto-configuration 试图自动配置你已经添加的基于 jar 依赖项的 Spring 应用程序。比如说，如果 HSQLDBis 存在你的类路径中，并且，数据库连接 bean 还没有手动配置，那么我们可以自动配置一个内存数据库。

  进一步的阅读：

  http://www.springboottutorial.com/spring-boot-auto-configuration

  ##

  问题二十九 我们如何连接一个像 MSSQL 或者 orcale 一样的外部数据库？

  让我们以 MySQL 为例来思考这个问题：

  第一步 - 把 mysql 连接器的依赖项添加至 pom.xml

  <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
  </dependency>
  

  第二步 - 从 pom.xml 中移除 H2 的依赖项

  或者至少把它作为测试的范围。

  <!--
  <dependency>
      <groupId>com.h2database</groupId>
      <artifactId>h2</artifactId>
  <scope>test</scope>
  </dependency>
  -->   
  

  第三步 - 安装你的 MySQL 数据库

  更多的来看看这里 -https://github.com/in28minutes/jpa-with-hibernate#installing-and-setting-up-mysql

  第四步 - 配置你的 MySQL 数据库连接

  配置 application.properties

  spring.jpa.hibernate.ddl-auto=none
  spring.datasource.url=jdbc:mysql://localhost:3306/todo_example
  spring.datasource.username=todouser
  spring.datasource.password=YOUR_PASSWORD   
  

  第五步 - 重新启动，你就准备好了！

  就是这么简单！

  ##

  问题三十 Spring Boot 配置的默认 H2 数据库的名字是上面？为什么默认的数据库名字是 testdb？

  在 application.properties 里面，列出了所有的默认值

  • https://docs.spring.io/spring-boot/docs/current/reference/html/common-application-properties.html

  找到下面的属性

  spring.datasource.name=testdb # Name of the datasource.
  

  如果你使用了 H2 内部存储数据库，它里面确定了 Spring Boot 用来安装你的 H2 数据库的名字。

  ##

  问题三十一 如果 H2 不在类路径里面，会出现上面情况？

  将会报下面的错误

  Cannot determine embedded database driver class for database type NONE
  

  把 H2 添加至 pom.xml 中，然后重启你的服务器

  <dependency>
      <groupId>com.h2database</groupId>
      <artifactId>h2</artifactId>
  <scope>runtime</scope>
  </dependency>
  

  ##

  问题三十二 你能否举一个以 ReadOnly 为事务管理的例子？

  • 当你从数据库读取内容的时候，你想把事物中的用户描述或者是其它描述设置为只读模式，以便于 Hebernate 不需要再次检查实体的变化。这是非常高效的。

  ##

  问题三十三 发布 Spring Boot 用户应用程序自定义配置的最好方法是什么？

  @Value 的问题在于，您可以通过应用程序分配你配置值。更好的操作是采取集中的方法。 你可以使用 @ConfigurationProperties 定义一个配置组件。

  @Component
  @ConfigurationProperties("basic")
  public class BasicConfiguration {
      private boolean value;
      private String message;
      private int number;
  

  你可以在 application.properties 中配置参数。

  basic.value: true
  basic.message: Dynamic Message
  basic.number: 100
  

  ##

  问题三十四 配置文件的需求是什么？

  企业应用程序的开发是复杂的，你需要混合的环境：

  • Dev
  • QA
  • Stage
  • Production

  在每个环境中，你想要不同的应用程序配置。

  配置文件有助于在不同的环境中进行不同的应用程序配置。

  Spring 和 Spring Boot 提供了你可以制定的功能。

  • 不同配置文件中，不同环境的配置是什么？
  • 为一个制定的环境设置活动的配置文件。

  Spring Boot 将会根据特定环境中设置的活动配置文件来选择应用程序的配置。

  问题三十五 如何使用配置文件通过 Spring Boot 配置特定环境的配置？

  配置文件不是设别环境的关键。

  在下面的例子中，我们将会用到两个配置文件

  • dev
  • prod

  缺省的应用程序配置在 application.properties 中。让我们来看下面的例子：

  application.properties

  basic.value= true
  basic.message= Dynamic Message
  basic.number= 100
  

  我们想要为 dev 文件自定义 application.properties 属性。我们需要创建一个名为 application-dev.properties 的文件，并且重写我们想要自定义的属性。

  application-dev.properties

  basic.message: Dynamic Message in DEV
  

  一旦你特定配置了配置文件，你需要在环境中设定一个活动的配置文件。

  有多种方法可以做到这一点：

  • 在 VM 参数中使用 Dspring.profiles.active=prod
  • 在 application.properties 中使用 spring.profiles.active=prod
  Read All

  ---

• spring interview question

  2018-10-23

  yuippe

  question

  spring  question
  • Question
  • 1. 什么是spring?

  Question

  1、什么是Spring框架？Spring框架有哪些主要模块？

  ​ Spring框架是一个为Java应用程序的开发提供了综合、广泛的基础性支持的Java平台。Spring帮助开发者解决了开发中基础性的问题，使得开发人员可以专注于应用程序的开发。Spring框架本身亦是按照设计模式精心打造，这使得我们可以在开发环境中安心的集成Spring框架，不必担心Spring是如何在后台进行工作的。

  ​ Spring框架至今已集成了20多个模块。这些模块主要被分如下图所示的核心容器、数据访问/集成,、Web、AOP（面向切面编程）、工具、消息和测试模块。

  更多信息：Spring 框架教程。

  2、使用Spring框架能带来哪些好处？

  下面列举了一些使用Spring框架带来的主要好处：

  ​ Dependency Injection(DI) 方法使得构造器和JavaBean properties文件中的依赖关系一目了然。 ​ 与EJB容器相比较，IoC容器更加趋向于轻量级。这样一来IoC容器在有限的内存和CPU资源的情况下进行应用程序的开发和发布就变得十分有利。 ​ Spring并没有闭门造车，Spring利用了已有的技术比如ORM框架、logging框架、J2EE、Quartz和JDK Timer，以及其他视图技术。 Spring框架是按照模块的形式来组织的。由包和类的编号就可以看出其所属的模块，开发者仅仅需要选用他们需要的模块即可。 要测试一项用Spring开发的应用程序十分简单，因为测试相关的环境代码都已经囊括在框架中了。更加简单的是，利用JavaBean形式的POJO类，可以很方便的利用依赖注入来写入测试数据。 ​ Spring的Web框架亦是一个精心设计的Web MVC框架，为开发者们在web框架的选择上提供了一个除了主流框架比如Struts、过度设计的、不流行web框架的以外的有力选项。 Spring提供了一个便捷的事务管理接口，适用于小型的本地事物处理（比如在单DB的环境下）和复杂的共同事物处理（比如利用JTA的复杂DB环境）。

  3、什么是控制反转(IOC)？什么是依赖注入？

  ​ 控制反转是应用于软件工程领域中的，在运行时被装配器对象来绑定耦合对象的一种编程技巧，对象之间耦合关系在编译时通常是未知的。在传统的编程方式中，业务逻辑的流程是由应用程序中的早已被设定好关联关系的对象来决定的。在使用控制反转的情况下，业务逻辑的流程是由对象关系图来决定的，该对象关系图由装配器负责实例化，这种实现方式还可以将对象之间的关联关系的定义抽象化。而绑定的过程是通过“依赖注入”实现的。

  ​ 控制反转是一种以给予应用程序中目标组件更多控制为目的设计范式，并在我们的实际工作中起到了有效的作用。

  依赖注入是在编译阶段尚未知所需的功能是来自哪个的类的情况下，将其他对象所依赖的功能对象实例化的模式。这就需要一种机制用来激活相应的组件以提供特定的功能，所以依赖注入是控制反转的基础。否则如果在组件不受框架控制的情况下，框架又怎么知道要创建哪个组件？

  在Java中依然注入有以下三种实现方式：

  构造器注入 Setter方法注入 接口注入

  4、请解释下Spring框架中的IoC？

  ​ Spring中的 org.springframework.beans 包和 org.springframework.context包构成了Spring框架IoC容器的基础。

  ​ BeanFactory 接口提供了一个先进的配置机制，使得任何类型的对象的配置成为可能。ApplicationContex接口对BeanFactory（是一个子接口）进行了扩展，在BeanFactory的基础上添加了其他功能，比如与Spring的AOP更容易集成，也提供了处理message resource的机制（用于国际化）、事件传播以及应用层的特别配置，比如针对Web应用的WebApplicationContext。

  org.springframework.beans.factory.BeanFactory 是Spring IoC容器的具体实现，用来包装和管理前面提到的各种bean。BeanFactory接口是Spring IoC 容器的核心接口。

  5、BeanFactory和ApplicationContext有什么区别？

  ​ BeanFactory 可以理解为含有bean集合的工厂类。BeanFactory 包含了种bean的定义，以便在接收到客户端请求时将对应的bean实例化。

  ​ BeanFactory还能在实例化对象的时生成协作类之间的关系。此举将bean自身与bean客户端的配置中解放出来。BeanFactory还包含了bean生命周期的控制，调用客户端的初始化方法（initialization methods）和销毁方法（destruction methods）。

  从表面上看，application context如同bean factory一样具有bean定义、bean关联关系的设置，根据请求分发bean的功能。但application context在此基础上还提供了其他的功能。

  提供了支持国际化的文本消息 统一的资源文件读取方式 已在监听器中注册的bean的事件 以下是三种较常见的 ApplicationContext 实现方式：

  `1``、ClassPathXmlApplicationContext：从classpath的XML配置文件中读取上下文，并生成上下文定义。应用程序上下文从程序环境变量中取得。`  `ApplicationContext context = ``new` `ClassPathXmlApplicationContext(“bean.xml”);``2``、FileSystemXmlApplicationContext ：由文件系统中的XML配置文件读取上下文。` `ApplicationContext context = ``new` `FileSystemXmlApplicationContext(“bean.xml”);``3``、XmlWebApplicationContext：由Web应用的XML文件读取上下文。`
  

  6、Spring有几种配置方式？

  将Spring配置到应用开发中有以下三种方式：

  基于XML的配置 基于注解的配置 基于Java的配置

  7、如何用基于XML配置的方式配置Spring？

  ​ 在Spring框架中，依赖和服务需要在专门的配置文件来实现，我常用的XML格式的配置文件。这些配置文件的格式通常用开头，然后一系列的bean定义和专门的应用配置选项组成。

  ​ SpringXML配置的主要目的时候是使所有的Spring组件都可以用xml文件的形式来进行配置。这意味着不会出现其他的Spring配置类型（比如声明的方式或基于Java Class的配置方式）

  ​ Spring的XML配置方式是使用被Spring命名空间的所支持的一系列的XML标签来实现的。Spring有以下主要的命名空间：context、beans、jdbc、tx、aop、mvc和aso。

  `<``beans``>`` ` `    ``<!-- JSON Support -->``    ``<``bean` `name``=``"viewResolver"` `class``=``"org.springframework.web.servlet.view.BeanNameViewResolver"``/>``    ``<``bean` `name``=``"jsonTemplate"` `class``=``"org.springframework.web.servlet.view.json.MappingJackson2JsonView"``/>`` ` `    ``<``bean` `id``=``"restTemplate"` `class``=``"org.springframework.web.client.RestTemplate"``/>`` ` `</``beans``>`
  

  下面这个web.xml仅仅配置了DispatcherServlet，这件最简单的配置便能满足应用程序配置运行时组件的需求。

  `<``web-app``>``  ``<``display-name``>Archetype Created Web Application</``display-name``>`` ` `  ``<``servlet``>``        ``<``servlet-name``>spring</``servlet-name``>``            ``<``servlet-class``>``                ``org.springframework.web.servlet.DispatcherServlet``            ``</``servlet-class``>``        ``<``load-on-startup``>1</``load-on-startup``>``    ``</``servlet``>`` ` `    ``<``servlet-mapping``>``        ``<``servlet-name``>spring</``servlet-name``>``        ``<``url-pattern``>/</``url-pattern``>``    ``</``servlet-mapping``>`` ` `</``web-app``>`
  

  8、如何用基于Java配置的方式配置Spring？

  ​ Spring对Java配置的支持是由@Configuration注解和@Bean注解来实现的。由@Bean注解的方法将会实例化、配置和初始化一个新对象，这个对象将由Spring的IoC容器来管理。@Bean声明所起到的作用与 元素类似。被@Configuration所注解的类则表示这个类的主要目的是作为bean定义的资源。被@Configuration声明的类可以通过在同一个类的内部调用@bean方法来设置嵌入bean的依赖关系。

  最简单的@Configuration 声明类请参考下面的代码：

  `@Configuration``public` `class` `AppConfig``{``    ``@Bean``    ``public` `MyService myService() {``        ``return` `new` `MyServiceImpl();``    ``}``}`
  

  对于上面的@Beans配置文件相同的XML配置文件如下：

  `<``beans``>``    ``<``bean` `id``=``"myService"` `class``=``"com.howtodoinjava.services.MyServiceImpl"``/>``</``beans``>`
  

  上述配置方式的实例化方式如下：利用AnnotationConfigApplicationContext 类进行实例化

  `public` `static` `void` `main(String[] args) {``    ``ApplicationContext ctx = ``new` `AnnotationConfigApplicationContext(AppConfig.``class``);``    ``MyService myService = ctx.getBean(MyService.``class``);``    ``myService.doStuff();``}`
  

  要使用组件组建扫描，仅需用@Configuration进行注解即可：

  `@Configuration``@ComponentScan``(basePackages = ``"com.howtodoinjava"``)``public` `class` `AppConfig  {``    ``...``}`
  

  在上面的例子中，com.acme包首先会被扫到，然后再容器内查找被@Component 声明的类，找到后将这些类按照Sring bean定义进行注册。

  如果你要在你的web应用开发中选用上述的配置的方式的话，需要用AnnotationConfigWebApplicationContext 类来读取配置文件，可以用来配置Spring的Servlet监听器ContrextLoaderListener或者Spring MVC的DispatcherServlet。

  `<``web-app``>``    ``<!-- Configure ContextLoaderListener to use AnnotationConfigWebApplicationContext``        ``instead of the default XmlWebApplicationContext -->``    ``<``context-param``>``        ``<``param-name``>contextClass</``param-name``>``        ``<``param-value``>``            ``org.springframework.web.context.support.AnnotationConfigWebApplicationContext``        ``</``param-value``>``    ``</``context-param``>`` ` `    ``<!-- Configuration locations must consist of one or more comma- or space-delimited``        ``fully-qualified @Configuration classes. Fully-qualified packages may also be``        ``specified for component-scanning -->``    ``<``context-param``>``        ``<``param-name``>contextConfigLocation</``param-name``>``        ``<``param-value``>com.howtodoinjava.AppConfig</``param-value``>``    ``</``context-param``>`` ` `    ``<!-- Bootstrap the root application context as usual using ContextLoaderListener -->``    ``<``listener``>``        ``<``listener-class``>org.springframework.web.context.ContextLoaderListener</``listener-class``>``    ``</``listener``>`` ` `    ``<!-- Declare a Spring MVC DispatcherServlet as usual -->``    ``<``servlet``>``        ``<``servlet-name``>dispatcher</``servlet-name``>``        ``<``servlet-class``>org.springframework.web.servlet.DispatcherServlet</``servlet-class``>``        ``<!-- Configure DispatcherServlet to use AnnotationConfigWebApplicationContext``            ``instead of the default XmlWebApplicationContext -->``        ``<``init-param``>``            ``<``param-name``>contextClass</``param-name``>``            ``<``param-value``>``                ``org.springframework.web.context.support.AnnotationConfigWebApplicationContext``            ``</``param-value``>``        ``</``init-param``>``        ``<!-- Again, config locations must consist of one or more comma- or space-delimited``            ``and fully-qualified @Configuration classes -->``        ``<``init-param``>``            ``<``param-name``>contextConfigLocation</``param-name``>``            ``<``param-value``>com.howtodoinjava.web.MvcConfig</``param-value``>``        ``</``init-param``>``    ``</``servlet``>`` ` `    ``<!-- map all requests for /app/* to the dispatcher servlet -->``    ``<``servlet-mapping``>``        ``<``servlet-name``>dispatcher</``servlet-name``>``        ``<``url-pattern``>/app/*</``url-pattern``>``    ``</``servlet-mapping``>``</``web-app``>`
  

  9、怎样用注解的方式配置Spring？

  ​ Spring在2.5版本以后开始支持用注解的方式来配置依赖注入。可以用注解的方式来替代XML方式的bean描述，可以将bean描述转移到组件类的内部，只需要在相关类上、方法上或者字段声明上使用注解即可。注解注入将会被容器在XML注入之前被处理，所以后者会覆盖掉前者对于同一个属性的处理结果。

  ​ 注解装配在Spring中是默认关闭的。所以需要在Spring文件中配置一下才能使用基于注解的装配模式。如果你想要在你的应用程序中使用关于注解的方法的话，请参考如下的配置。

  `<``beans``>`` ` `   ``<``context:annotation-config``/>``   ``<!-- bean definitions go here -->`` ` `</``beans``>`
  

  在 标签配置完成以后，就可以用注解的方式在Spring中向属性、方法和构造方法中自动装配变量。

  下面是几种比较重要的注解类型：

  @Required：该注解应用于设值方法。 @Autowired：该注解应用于有值设值方法、非设值方法、构造方法和变量。 @Qualifier：该注解和@Autowired注解搭配使用，用于消除特定bean自动装配的歧义。 JSR-250 Annotations：Spring支持基于JSR-250 注解的以下注解，@Resource、@PostConstruct 和 @PreDestroy。

  10、请解释Spring Bean的生命周期？

  ​ Spring Bean的生命周期简单易懂。在一个bean实例被初始化时，需要执行一系列的初始化操作以达到可用的状态。同样的，当一个bean不在被调用时需要进行相关的析构操作，并从bean容器中移除。

  ​ Spring bean factory 负责管理在spring容器中被创建的bean的生命周期。Bean的生命周期由两组回调（call back）方法组成。

  ​ 初始化之后调用的回调方法。 ​ 销毁之前调用的回调方法。 ​ Spring框架提供了以下四种方式来管理bean的生命周期事件：

  ​ InitializingBean和DisposableBean回调接口 ​ 针对特殊行为的其他Aware接口 ​ Bean配置文件中的Custom init()方法和destroy()方法 ​ @PostConstruct和@PreDestroy注解方式 ​ 使用customInit()和 customDestroy()方法管理bean生命周期的代码样例如下：

  `<``beans``>``    ``<``bean` `id``=``"demoBean"` `class``=``"com.howtodoinjava.task.DemoBean"``            ``init-method``=``"customInit"` `destroy-method``=``"customDestroy"``></``bean``>``</``beans``>`
  

  更多内容请参考：Spring生命周期Spring Bean Life Cycle。

  11、Spring Bean的作用域之间有什么区别？

  ​ Spring容器中的bean可以分为5个范围。所有范围的名称都是自说明的，但是为了避免混淆，还是让我们来解释一下：

  singleton：这种bean范围是默认的，这种范围确保不管接受到多少个请求，每个容器中只有一个bean的实例，单例的模式由bean factory自身来维护。 prototype：原形范围与单例范围相反，为每一个bean请求提供一个实例。 request：在请求bean范围内会每一个来自客户端的网络请求创建一个实例，在请求完成以后，bean会失效并被垃圾回收器回收。 Session：与请求范围类似，确保每个session中有一个bean的实例，在session过期后，bean会随之失效。 global-session：global-session和Portlet应用相关。当你的应用部署在Portlet容器中工作时，它包含很多portlet。如果你想要声明让所有的portlet共用全局的存储变量的话，那么这全局变量需要存储在global-session中。 全局作用域与Servlet中的session作用域效果相同。

  更多内容请参考 : Spring Bean Scopes。

  1. 什么是spring?

  Spring 是个java企业级应用的开源开发框架。Spring主要用来开发Java应用，但是有些扩展是针对构建J2EE平台的web应用。Spring 框架目标是简化Java企业级应用开发，并通过POJO为基础的编程模型促进良好的编程习惯。

  Read All

  ---

• java interview question

  2018-10-23

  yuippe

  question

  java  question
  • question

  question

  Java是一个支持并发、基于类和面向对象的计算机编程语言。下面列出了面向对象软件开发的优点：

  • 代码开发模块化，更易维护和修改。
  • 代码复用。
  • 增强代码的可靠性和灵活性。
  • 增加代码的可理解性。

  面向对象编程有很多重要的特性，比如：封装，继承，多态和抽象。下面的章节我们会逐个分析这些特性。

  封装

  封装给对象提供了隐藏内部特性和行为的能力。对象提供一些能被其他对象访问的方法来改变它内部的数据。在Java当中，有3种修饰符：public，private和protected。每一种修饰符给其他的位于同一个包或者不同包下面对象赋予了不同的访问权限。

  下面列出了使用封装的一些好处：

  • 通过隐藏对象的属性来保护对象内部的状态。
  • 提高了代码的可用性和可维护性，因为对象的行为可以被单独的改变或者是扩展。
  • 禁止对象之间的不良交互提高模块化。

  参考这个文档获取更多关于封装的细节和示例。

  多态

  多态是编程语言给不同的底层数据类型做相同的接口展示的一种能力。一个多态类型上的操作可以应用到其他类型的值上面。

  继承

  继承给对象提供了从基类获取字段和方法的能力。继承提供了代码的重用行，也可以在不修改类的情况下给现存的类添加新特性。

  抽象

  抽象是把想法从具体的实例中分离出来的步骤，因此，要根据他们的功能而不是实现细节来创建类。Java支持创建只暴漏接口而不包含方法实现的抽象的类。这种抽象技术的主要目的是把类的行为和实现细节分离开。

  抽象和封装的不同点

  抽象和封装是互补的概念。一方面，抽象关注对象的行为。另一方面，封装关注对象行为的细节。一般是通过隐藏对象内部状态信息做到封装，因此，封装可以看成是用来提供抽象的一种策略。

  常见的Java问题

  1.什么是Java虚拟机？为什么Java被称作是“平台无关的编程语言”？

  Java虚拟机是一个可以执行Java字节码的虚拟机进程。Java源文件被编译成能被Java虚拟机执行的字节码文件。

  Java被设计成允许应用程序可以运行在任意的平台，而不需要程序员为每一个平台单独重写或者是重新编译。Java虚拟机让这个变为可能，因为它知道底层硬件平台的指令长度和其他特性。

  2.JDK和JRE的区别是什么？

  Java运行时环境(JRE)是将要执行Java程序的Java虚拟机。它同时也包含了执行applet需要的浏览器插件。Java开发工具包(JDK)是完整的Java软件开发包，包含了JRE，编译器和其他的工具(比如：JavaDoc，Java调试器)，可以让开发者开发、编译、执行Java应用程序。

  3.”static”关键字是什么意思？Java中是否可以覆盖(override)一个private或者是static的方法？

  “static”关键字表明一个成员变量或者是成员方法可以在没有所属的类的实例变量的情况下被访问。

  Java中static方法不能被覆盖，因为方法覆盖是基于运行时动态绑定的，而static方法是编译时静态绑定的。static方法跟类的任何实例都不相关，所以概念上不适用。

  4.是否可以在static环境中访问非static变量？

  static变量在Java中是属于类的，它在所有的实例中的值是一样的。当类被Java虚拟机载入的时候，会对static变量进行初始化。如果你的代码尝试不用实例来访问非static的变量，编译器会报错，因为这些变量还没有被创建出来，还没有跟任何实例关联上。

  5.Java支持的数据类型有哪些？什么是自动拆装箱？

  Java语言支持的8中基本数据类型是：

  • byte
  • short
  • int
  • long
  • float
  • double
  • boolean
  • char

  自动装箱是Java编译器在基本数据类型和对应的对象包装类型之间做的一个转化。比如：把int转化成Integer，double转化成double，等等。反之就是自动拆箱。

  6.Java中的方法覆盖(Overriding)和方法重载(Overloading)是什么意思？

  Java中的方法重载发生在同一个类里面两个或者是多个方法的方法名相同但是参数不同的情况。与此相对，方法覆盖是说子类重新定义了父类的方法。方法覆盖必须有相同的方法名，参数列表和返回类型。覆盖者可能不会限制它所覆盖的方法的访问。

  7.Java中，什么是构造函数？什么是构造函数重载？什么是复制构造函数？

  当新对象被创建的时候，构造函数会被调用。每一个类都有构造函数。在程序员没有给类提供构造函数的情况下，Java编译器会为这个类创建一个默认的构造函数。

  Java中构造函数重载和方法重载很相似。可以为一个类创建多个构造函数。每一个构造函数必须有它自己唯一的参数列表。

  Java不支持像C++中那样的复制构造函数，这个不同点是因为如果你不自己写构造函数的情况下，Java不会创建默认的复制构造函数。

  8.Java支持多继承么？

  不支持，Java不支持多继承。每个类都只能继承一个类，但是可以实现多个接口。

  9.接口和抽象类的区别是什么？

  Java提供和支持创建抽象类和接口。它们的实现有共同点，不同点在于：

  • 接口中所有的方法隐含的都是抽象的。而抽象类则可以同时包含抽象和非抽象的方法。
  • 类可以实现很多个接口，但是只能继承一个抽象类
  • 类如果要实现一个接口，它必须要实现接口声明的所有方法。但是，类可以不实现抽象类声明的所有方法，当然，在这种情况下，类也必须得声明成是抽象的。
  • 抽象类可以在不提供接口方法实现的情况下实现接口。
  • Java接口中声明的变量默认都是final的。抽象类可以包含非final的变量。
  • Java接口中的成员函数默认是public的。抽象类的成员函数可以是private，protected或者是public。
  • 接口是绝对抽象的，不可以被实例化。抽象类也不可以被实例化，但是，如果它包含main方法的话是可以被调用的。

  也可以参考JDK8中抽象类和接口的区别

  10.什么是值传递和引用传递？

  对象被值传递，意味着传递了对象的一个副本。因此，就算是改变了对象副本，也不会影响源对象的值。

  对象被引用传递，意味着传递的并不是实际的对象，而是对象的引用。因此，外部对引用对象所做的改变会反映到所有的对象上。

  Java线程

  11.进程和线程的区别是什么？

  进程是执行着的应用程序，而线程是进程内部的一个执行序列。一个进程可以有多个线程。线程又叫做轻量级进程。

  12.创建线程有几种不同的方式？你喜欢哪一种？为什么？

  有三种方式可以用来创建线程：

  • 继承Thread类
  • 实现Runnable接口
  • 应用程序可以使用Executor框架来创建线程池

  实现Runnable接口这种方式更受欢迎，因为这不需要继承Thread类。在应用设计中已经继承了别的对象的情况下，这需要多继承（而Java不支持多继承），只能实现接口。同时，线程池也是非常高效的，很容易实现和使用。

  13.概括的解释下线程的几种可用状态。

  线程在执行过程中，可以处于下面几种状态：

  • 就绪(Runnable):线程准备运行，不一定立马就能开始执行。
  • 运行中(Running)：进程正在执行线程的代码。
  • 等待中(Waiting):线程处于阻塞的状态，等待外部的处理结束。
  • 睡眠中(Sleeping)：线程被强制睡眠。
  • I/O阻塞(Blocked on I/O)：等待I/O操作完成。
  • 同步阻塞(Blocked on Synchronization)：等待获取锁。
  • 死亡(Dead)：线程完成了执行。

  14.同步方法和同步代码块的区别是什么？

  在Java语言中，每一个对象有一把锁。线程可以使用synchronized关键字来获取对象上的锁。synchronized关键字可应用在方法级别(粗粒度锁)或者是代码块级别(细粒度锁)。

  15.在监视器(Monitor)内部，是如何做线程同步的？程序应该做哪种级别的同步？

  监视器和锁在Java虚拟机中是一块使用的。监视器监视一块同步代码块，确保一次只有一个线程执行同步代码块。每一个监视器都和一个对象引用相关联。线程在获取锁之前不允许执行同步代码。

  16.什么是死锁(deadlock)？

  两个进程都在等待对方执行完毕才能继续往下执行的时候就发生了死锁。结果就是两个进程都陷入了无限的等待中。

  17.如何确保N个线程可以访问N个资源同时又不导致死锁？

  使用多线程的时候，一种非常简单的避免死锁的方式就是：指定获取锁的顺序，并强制线程按照指定的顺序获取锁。因此，如果所有的线程都是以同样的顺序加锁和释放锁，就不会出现死锁了。

  Java集合类

  18.Java集合类框架的基本接口有哪些？

  集合类接口指定了一组叫做元素的对象。集合类接口的每一种具体的实现类都可以选择以它自己的方式对元素进行保存和排序。有的集合类允许重复的键，有些不允许。

  Java集合类提供了一套设计良好的支持对一组对象进行操作的接口和类。Java集合类里面最基本的接口有：

  • Collection：代表一组对象，每一个对象都是它的子元素。
  • Set：不包含重复元素的Collection。
  • List：有顺序的collection，并且可以包含重复元素。
  • Map：可以把键(key)映射到值(value)的对象，键不能重复。

  19.为什么集合类没有实现Cloneable和Serializable接口？

  克隆(cloning)或者是序列化(serialization)的语义和含义是跟具体的实现相关的。因此，应该由集合类的具体实现来决定如何被克隆或者是序列化。

  20.什么是迭代器(Iterator)？

  Iterator接口提供了很多对集合元素进行迭代的方法。每一个集合类都包含了可以返回迭代器实例的

  Read All

  ---

• enable eth0 online in the vmware

  2018-10-22

  yuippe

  tips

  vmware10  eth0  online
  • 背景
  • 解决方案

  背景

  在VMware10中安装好centos6.8，然后通过ping www.baidu.com，发现无法识别域名，本地也没有IP（如下所示），初步定位是网卡没有配置，并且没有开启服务。

  

  下面针对此情况，进行配置。

  解决方案

  步骤如下：

  1. 在vmware选中对应虚拟机，点击设置，然后在硬件tab页中选中网络适配器，将网络连接选中桥接模式

     

  2. 找到网卡对应配置文件

     cd /etc/sysconfig/network-scripts/
     vim ifcfg-eth0
     #将ONBOOT=no改为yes
     

     

  3. 重新启动网卡

     /etc/init.d/network restart
     

     

  4. 检查网卡信息

     ifconfig eth0
     

     

  Read All

  ---

• Centos6.8 firewall configuration

  2018-10-22

  yuippe

  tips

  Centos6.8  firewall
  • 背景
  • 解决方案

  背景

  本地虚拟机安装mysql服务后，虚拟机访问正常，也开通了远程root访问权限，但通过本地navicat访问不了，初步判断是由于防火墙问题导致。

  下面给出防火墙相关配置。

  解决方案

  1. 查看防火墙状态

     service iptables status
     ##从如下可以看出，对外只开通了22端口
     

     

  2. 编辑iptables，将3306端口对外开放

     vim /etc/sysconfig/iptables
     #增加如下一行
     -A INPUT -m state --state NEW -m tcp -p tcp --dport 3306 -j ACCEPT
     

     

  3. 重新启动防火墙服务

     service iptables restart
     

  Read All

  ---