问题一 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
文章来源: http://www.3xmq.com/article/1522809264295
【程序员面试】是IT求职神器,提供海量C++、JAVA、前端等职业笔试题库,在线进行一线互联网名企笔试面试模拟考试练习,天天刷题,和牛人一起讨论经典试题,全面提升你的编程能力,海量高薪职位信息等着你!永远为下个月离职做好准备!年薪百万的码农都已关注!
========================================================================================
================================================================================================
问题一: 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 的问题在于需要配置大量的参数。
我们能否带来更多的智能?当一个 MVC JAR 添加到应用程序中的时候,我们能否自动配置一些 beans?
Spring 查看(CLASSPATH 上可用的框架)已存在的应用程序的配置。在此基础上,Spring Boot 提供了配置应用程序和框架所需要的基本配置。这就是自动配置
问题三:什么是 Spring Boot Stater ?
这些依赖项。Spring Boot Starter Web 预先打包了这些依赖项。
作为一个开发者,我不需要再担心这些依赖项和它们的兼容版本
问题六: 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 已经不再支持
问题七:为什么我们需要 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>
重启应用程序,然后就可以了。
问题九 什么是嵌入式服务器?我们为什么要使用嵌入式服务器呢?
思考一下在你的虚拟机上部署应用程序需要些什么。
第一步: 安装 Java
第二部: 安装 Web 或者是应用程序的服务器(Tomat/Wbesphere/Weblogic 等等)
第三部: 部署应用程序 war 包
如果我们想简化这些步骤,应该如何做呢?
让我们来思考如何使服务器成为应用程序的一部分?
你只需要一个安装了 Java 的虚拟机,就可以直接在上面部署应用程序了,
是不是很爽?
这个想法是嵌入式服务器的起源。
当我们创建一个可以部署的应用程序的时候,我们将会把服务器(例如,tomcat)嵌入到可部署的服务器中。
例如,对于一个 Spring Boot 应用程序来说,你可以生成一个包含 Embedded Tomcat 的应用程序 jar。你就可以想运行正常 Java 应用程序一样来运行 web 应用程序了。
嵌入式服务器就是我们的可执行单元包含服务器的二进制文件(例如,tomcat.jar)。
问题十 如何使用 Spring Boot 部署到不同的服务器?
你需要做下面两个步骤:
-
在一个项目中生成一个 war 文件。
-
将它部署到你最喜欢的服务器(websphere 或者 Weblogic 或者 Tomcat and so on)。
问题十一 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 在快速原型构造上面,或者作为项目的初始解决方法。对于完整演变项目来说,这并不是一个好的注意。
问题十三 JPA 和 Hibernate 有哪些区别?
简而言之
- JPA 是一个规范或者接口
- Hibernate 是 JPA 的一个实现
当我们使用 JPA 的时候,我们使用 javax.persistence 包中的注释和接口时,不需要使用 hibernate 的导入包。
我们建议使用 JPA 注释,因为哦我们没有将其绑定到 Hibernate 作为实现。后来(我知道 - 小于百分之一的几率),我们可以使用另一种 JPA 实现。
问题十四 业务边界应该从哪一层开始?
我们建议在服务层管理义务。商业业务逻辑在商业层或者服务层,与此同时,你想要执行的业务管理也在该层。
问题十五 如何不通过任何配置来选择 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 用户应用程序自定义配置的最好方法是什么?
@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
一. 什么是springboot
1.用来简化spring应用的初始搭建以及开发过程 使用特定的方式来进行配置(properties或yml文件)
2.创建独立的spring引用程序 main方法运行
3.嵌入的Tomcat 无需部署war文件
4.简化maven配置
5.自动配置spring添加对应功能starter自动化配置
二.springboot常用的starter有哪些
可以去Maven仓库中搜索以下插件,pom文件依赖即可
Maven仓库官网:http://mvnrepository.com/
1.spring-boot-starter-web (嵌入tomcat和web开发需要servlet与jsp支持)
2.spring-boot-starter-data-jpa (数据库支持)
3.spring-boot-starter-data-redis (redis数据库支持)
4.spring-boot-starter-data-solr (solr搜索应用框架支持)
5.mybatis-spring-boot-starter (第三方的mybatis集成starter)
三. springboot自动配置的原理
1.@EnableAutoConfiguration这个注释告诉SpringBoot“猜”你将如何想配置Spring,基于你已经添加jar依赖项。如果spring-boot-starter-web已经添加Tomcat和Spring MVC,这个注释自动将假设您正在开发一个web应用程序并添加相应的spring设置。会自动去maven中读取每个starter中的spring.factories文件 该文件里配置了所有需要被创建spring容器中的bean
2.使用@SpringbootApplication注解 可以解决根类或者配置类(我自己的说法,就是main所在类)头上注解过多的问题,一个@SpringbootApplication相当于@Configuration,@EnableAutoConfiguration和 @ComponentScan 并具有他们的默认属性值
四.springboot读取配置文件的方式
springboot默认读取配置文件为application.properties或者是application.yml
作者:HaleyLiu
链接:https://www.jianshu.com/p/0674c1544edf
來源:简书
简书著作权归作者所有,任何形式的转载都请联系作者获得授权并注明出处。
五. springboot如何添加【修改代码】自动重启功能
添加开发者工具集=====spring-boot-devtools
六.微服务
以前的模式是 所有的代码在同一个工程中 部署在同一个服务器中 同一个项目的不同模块不同功能互相抢占资源
微服务 将工程根据不同的业务规则拆分成微服务 微服务部署在不同的机器上 服务之间进行相互调用
Java微服务的框架有 dubbo(只能用来做微服务),spring cloud(提供了服务的发现,断路器等)
七. springcloud如何实现服务的注册和发现
服务在发布时 指定对应的服务名(服务名包括了IP地址和端口) 将服务注册到注册中心(eureka或者zookeeper)
这一过程是springcloud自动实现 只需要在main方法添加@EnableDisscoveryClient 同一个服务修改端口就可以启动多个实例
调用方法:传递服务名称通过注册中心获取所有的可用实例 通过负载均衡策略调用(ribbon和feign)对应的服务
作者:HaleyLiu
链接:https://www.jianshu.com/p/0674c1544edf
來源:简书
简书著作权归作者所有,任何形式的转载都请联系作者获得授权并注明出处。
1.常见的starter会包几个方面的内容?分别是什么?
// 常见的starter会包括下面四个方面的内容
// 自动配置文件,根据classpath是否存在指定的类来决定是否要执行该功能的自动配置。
// spring.factories,非常重要,指导Spring Boot找到指定的自动配置文件。
// endpoint:可以理解为一个admin,包含对服务的描述、界面、交互(业务信息的查询)。
// health indicator:该starter提供的服务的健康指标。
两个需要注意的点:
// 1. @ConditionalOnMissingBean的作用是:只有对应的bean在系统中都没有被创建,它修饰的初始化代码块才会执行,【用户自己手动创建的bean优先】。
// 2. Spring Boot Starter找到自动配置文件(xxxxAutoConfiguration之类的文件)的方式有两种:
// spring.factories:由Spring Boot触发探测classpath目录下的类,进行自动配置;
// @EnableXxxxx:有时需要由starter的用户触发*查找自动配置文件的过程
2.总结Spring Boot Starter的工作原理
// Spring Boot Starter的工作原理如下:
// 1. Spring Boot 在启动时扫描项目所依赖的JAR包,寻找包含spring.factories文件的JAR
// 2. 根据spring.factories配置加载AutoConfigure类
// 3. 根据 @Conditional注解的条件,进行自动配置并将Bean注入Spring Context
3.谈谈你对Spring Boot的认识。
// spring Boot是一个开源框架,它可用于创建可执行的Spring应用程序,采用了习惯优于配置的方法。此框架的神奇之处在于@EnableAutoConfiguration注解,此注解自动载入应用程序所需的所有Bean——这依赖于Spring Boot在类路径中的查找。
1. @Enable*注解
@Enable*注解并不是新发明的注解,早在Spring 3框架就引入了这些注解,用这些注解替代XML配置文件。
很多Spring开发者都知道@EnableTransactionManagement注解,它能够声明事务管理;@EnableWebMvc注解,它能启用Spring MVC;以及@EnableScheduling注解,它可以初始化一个调度器。
2. 属性映射
下面看MongoProperties类,它是一个Spring Boot属性映射的例子:
@ConfigurationProperties(prefix = "spring.data.mongodb")
public class MongoProperties {
private String host;
private int port = DBPort.PORT;
private String uri = "mongodb://localhost/test";
private String database;
// ... getters/ setters omitted
}
@ConfigurationProperties注解将POJO关联到指定前缀的每一个属性。例如,spring.data.mongodb.port属性将映射到这个类的端口属性。
强烈建议Spring Boot开发者使用这种方式来删除与配置属性相关的瓶颈代码。
3.@Conditional注解
Spring Boot的强大之处在于使用了Spring 4框架的新特性:@Conditional注解,此注解使得只有在特定条件满足时才启用一些配置。
在Spring Boot的org.springframework.boot.autoconfigure.condition包中说明了使用@Conditional注解能给我们带来什么,下面对这些注解做一个概述:
@ConditionalOnBean
@ConditionalOnClass
@ConditionalOnExpression
@ConditionalOnMissingBean
@ConditionalOnMissingClass
@ConditionalOnNotWebApplication
@ConditionalOnResource
@ConditionalOnWebApplication
4.应用程序上下文初始化器
spring.factories还提供了第二种可能性,即定义应用程序的初始化。这使得我们可以在应用程序载入前操纵Spring的应用程序上下文ApplicationContext。
特别是,可以在上下文创建监听器,使用ConfigurableApplicationContext类的addApplicationListener()方法。
AutoConfigurationReportLoggingInitializer监听到系统事件时,比如上下文刷新或应用程序启动故障之类的事件,Spring Boot可以执行一些工作。这有助于我们以调试模式启动应用程序时创建自动配置的报告。
要以调试模式启动应用程序,可以使用-Ddebug标识,或者在application.properties文件这添加属性debug= true。
4.自定义springboot-starter注意事项
// 1. springboot默认scan的包名是其main类所在的包名。如果引入的starter包名不一样,需要自己添加scan。
@ComponentScan(basePackages = {"com.xixicat.demo","com.xixicat.sms"})
// 2. 对于starter中有feign的,需要额外指定
@EnableFeignClients(basePackages = {"com.xixicat.sms"})
// 3. 对于exclude一些autoConfig
@EnableAutoConfiguration(exclude = {MetricFilterAutoConfiguration.class})
Spring 概述
1. 什么是spring?
Spring 是个java企业级应用的开源开发框架。Spring主要用来开发Java应用,但是有些扩展是针对构建J2EE平台的web应用。Spring 框架目标是简化Java企业级应用开发,并通过POJO为基础的编程模型促进良好的编程习惯。
2. 使用Spring框架的好处是什么?
- 轻量:Spring 是轻量的,基本的版本大约2MB。
- 控制反转:Spring通过控制反转实现了松散耦合,对象们给出它们的依赖,而不是创建或查找依赖的对象们。
- 面向切面的编程(AOP):Spring支持面向切面的编程,并且把应用业务逻辑和系统服务分开。
- 容器:Spring 包含并管理应用中对象的生命周期和配置。
- MVC框架:Spring的WEB框架是个精心设计的框架,是Web框架的一个很好的替代品。
- 事务管理:Spring 提供一个持续的事务管理接口,可以扩展到上至本地事务下至全局事务(JTA)。
- 异常处理:Spring 提供方便的API把具体技术相关的异常(比如由JDBC,Hibernate or JDO抛出的)转化为一致的unchecked 异常。
3. Spring由哪些模块组成?
以下是Spring 框架的基本模块:
- Core module
- Bean module
- Context module
- Expression Language module
- JDBC module
- ORM module
- OXM module
- Java Messaging Service(JMS) module
- Transaction module
- Web module
- Web-Servlet module
- Web-Struts module
- Web-Portlet module
4. 核心容器(应用上下文) 模块。
这是基本的Spring模块,提供spring 框架的基础功能,BeanFactory 是 任何以spring为基础的应用的核心。Spring 框架建立在此模块之上,它使Spring成为一个容器。
5. BeanFactory – BeanFactory 实现举例。
Bean 工厂是工厂模式的一个实现,提供了控制反转功能,用来把应用的配置和依赖从正真的应用代码中分离。
最常用的BeanFactory 实现是XmlBeanFactory 类。
6. XMLBeanFactory
最常用的就是org.springframework.beans.factory.xml.XmlBeanFactory ,它根据XML文件中的定义加载beans。该容器从XML 文件读取配置元数据并用它去创建一个完全配置的系统或应用。
7. 解释AOP模块
AOP模块用于发给我们的Spring应用做面向切面的开发, 很多支持由AOP联盟提供,这样就确保了Spring和其他AOP框架的共通性。这个模块将元数据编程引入Spring。
8. 解释JDBC抽象和DAO模块。
通过使用JDBC抽象和DAO模块,保证数据库代码的简洁,并能避免数据库资源错误关闭导致的问题,它在各种不同的数据库的错误信息之上,提供了一个统一的异常访问层。它还利用Spring的AOP 模块给Spring应用中的对象提供事务管理服务。
9. 解释对象/关系映射集成模块。
Spring 通过提供ORM模块,支持我们在直接JDBC之上使用一个对象/关系映射映射(ORM)工具,Spring 支持集成主流的ORM框架,如Hiberate,JDO和 iBATIS SQL Maps。Spring的事务管理同样支持以上所有ORM框架及JDBC。
10. 解释WEB 模块。
Spring的WEB模块是构建在application context 模块基础之上,提供一个适合web应用的上下文。这个模块也包括支持多种面向web的任务,如透明地处理多个文件上传请求和程序级请求参数的绑定到你的业 务对象。它也有对Jakarta Struts的支持。
12. Spring配置文件
Spring配置文件是个XML 文件,这个文件包含了类信息,描述了如何配置它们,以及如何相互调用。
13. 什么是Spring IOC 容器?
Spring IOC 负责创建对象,管理对象(通过依赖注入(DI),装配对象,配置对象,并且管理这些对象的整个生命周期。
14. IOC的优点是什么?
IOC 或 依赖注入把应用的代码量降到最低。它使应用容易测试,单元测试不再需要单例和JNDI查找机制。最小的代价和最小的侵入性使松散耦合得以实现。IOC容器支持加载服务时的饿汉式初始化和懒加载。
15. ApplicationContext通常的实现是什么?
- FileSystemXmlApplicationContext :此容器从一个XML文件中加载beans的定义,XML Bean 配置文件的全路径名必须提供给它的构造函数。
- ClassPathXmlApplicationContext:此容器也从一个XML文件中加载beans的定义,这里,你需要正确设置classpath因为这个容器将在classpath里找bean配置。
- WebXmlApplicationContext:此容器加载一个XML文件,此文件定义了一个WEB应用的所有bean。
16. Bean 工厂和 Application contexts 有什么区别?
Application contexts提供一种方法处理文本消息,一个通常的做法是加载文件资源(比如镜像),它们可以向注册为监听器的bean发布事件。另外,在容器或容器 内的对象上执行的那些不得不由bean工厂以程序化方式处理的操作,可以在Application contexts中以声明的方式处理。Application contexts实现了MessageSource接口,该接口的实现以可插拔的方式提供获取本地化消息的方法。
17. 一个Spring的应用看起来象什么?
- 一个定义了一些功能的接口。
- 这实现包括属性,它的Setter , getter 方法和函数等。
- Spring AOP。
- Spring 的XML 配置文件。
- 使用以上功能的客户端程序。
依赖注入
18. 什么是Spring的依赖注入?
依赖注入,是IOC的一个方面,是个通常的概念,它有多种解释。这概念是说你不用创建对象,而只需要描述它如何被创建。你不在代码里直接组装你的组件和服务,但是要在配置文件里描述哪些组件需要哪些服务,之后一个容器(IOC容器)负责把他们组装起来。
19. 有哪些不同类型的IOC(依赖注入)方式?
- 构造器依赖注入:构造器依赖注入通过容器触发一个类的构造器来实现的,该类有一系列参数,每个参数代表一个对其他类的依赖。
- Setter方法注入:Setter方法注入是容器通过调用无参构造器或无参static工厂 方法实例化bean之后,调用该bean的setter方法,即实现了基于setter的依赖注入。
20. 哪种依赖注入方式你建议使用,构造器注入,还是 Setter方法注入?
你两种依赖方式都可以使用,构造器注入和Setter方法注入。最好的解决方案是用构造器参数实现强制依赖,setter方法实现可选依赖。
Spring Beans
21.什么是Spring beans?
Spring beans 是那些形成Spring应用的主干的java对象。它们被Spring IOC容器初始化,装配,和管理。这些beans通过容器中配置的元数据创建。比如,以XML文件中<bean/> 的形式定义。
Spring 框架定义的beans都是单件beans。在bean tag中有个属性”singleton”,如果它被赋为TRUE,bean 就是单件,否则就是一个 prototype bean。默认是TRUE,所以所有在Spring框架中的beans 缺省都是单件。
22. 一个 Spring Bean 定义 包含什么?
一个Spring Bean 的定义包含容器必知的所有配置元数据,包括如何创建一个bean,它的生命周期详情及它的依赖。
23. 如何给Spring 容器提供配置元数据?
这里有三种重要的方法给Spring 容器提供配置元数据。
XML配置文件。
基于注解的配置。
基于java的配置。
24. 你怎样定义类的作用域?
当定义一个<bean> 在Spring里,我们还能给这个bean声明一个作用域。它可以通过bean 定义中的scope属性来定义。如,当Spring要在需要的时候每次生产一个新的bean实例,bean的scope属性被指定为prototype。 另一方面,一个bean每次使用的时候必须返回同一个实例,这个bean的scope 属性 必须设为 singleton。
25. 解释Spring支持的几种bean的作用域。
Spring框架支持以下五种bean的作用域:
- singleton : bean在每个Spring ioc 容器中只有一个实例。
- prototype:一个bean的定义可以有多个实例。
- request:每次http请求都会创建一个bean,该作用域仅在基于web的Spring ApplicationContext情形下有效。
- session:在一个HTTP Session中,一个bean定义对应一个实例。该作用域仅在基于web的Spring ApplicationContext情形下有效。
- global-session:在一个全局的HTTP Session中,一个bean定义对应一个实例。该作用域仅在基于web的Spring ApplicationContext情形下有效。
缺省的Spring bean 的作用域是Singleton.
26. Spring框架中的单例bean是线程安全的吗?
不,Spring框架中的单例bean不是线程安全的。
27. 解释Spring框架中bean的生命周期。
- Spring容器 从XML 文件中读取bean的定义,并实例化bean。
- Spring根据bean的定义填充所有的属性。
- 如果bean实现了BeanNameAware 接口,Spring 传递bean 的ID 到 setBeanName方法。
- 如果Bean 实现了 BeanFactoryAware 接口, Spring传递beanfactory 给setBeanFactory 方法。
- 如果有任何与bean相关联的BeanPostProcessors,Spring会在postProcesserBeforeInitialization()方法内调用它们。
- 如果bean实现IntializingBean了,调用它的afterPropertySet方法,如果bean声明了初始化方法,调用此初始化方法。
- 如果有BeanPostProcessors 和bean 关联,这些bean的postProcessAfterInitialization() 方法将被调用。
- 如果bean实现了 DisposableBean,它将调用destroy()方法。
28. 哪些是重要的bean生命周期方法? 你能重载它们吗?
有两个重要的bean 生命周期方法,第一个是setup , 它是在容器加载bean的时候被调用。第二个方法是 teardown 它是在容器卸载类的时候被调用。
The bean 标签有两个重要的属性(init-method和destroy-method)。用它们你可以自己定制初始化和注销方法。它们也有相应的注解(@PostConstruct和@PreDestroy)。
29. 什么是Spring的内部bean?
当一个bean仅被用作另一个bean的属性时,它能被声明为一个内部bean,为了定义inner bean,在Spring 的 基于XML的 配置元数据中,可以在 <property/>或 <constructor-arg/> 元素内使用<bean/> 元素,内部bean通常是匿名的,它们的Scope一般是prototype。
30. 在 Spring中如何注入一个java集合?
Spring提供以下几种集合的配置元素:
- <list>类型用于注入一列值,允许有相同的值。
- <set> 类型用于注入一组值,不允许有相同的值。
- <map> 类型用于注入一组键值对,键和值都可以为任意类型。
- <props>类型用于注入一组键值对,键和值都只能为String类型。
31. 什么是bean装配?
装配,或bean 装配是指在Spring 容器中把bean组装到一起,前提是容器需要知道bean的依赖关系,如何通过依赖注入来把它们装配到一起。
32. 什么是bean的自动装配?
Spring 容器能够自动装配相互合作的bean,这意味着容器不需要<constructor-arg>和<property>配置,能通过Bean工厂自动处理bean之间的协作。
33. 解释不同方式的自动装配 。
有五种自动装配的方式,可以用来指导Spring容器用自动装配方式来进行依赖注入。
- no:默认的方式是不进行自动装配,通过显式设置ref 属性来进行装配。
- byName:通过参数名 自动装配,Spring容器在配置文件中发现bean的autowire属性被设置成byname,之后容器试图匹配、装配和该bean的属性具有相同名字的bean。
- byType::通过参数类型自动装配,Spring容器在配置文件中发现bean的autowire属性被设置成byType,之后容器试图匹配、装配和该bean的属性具有相同类型的bean。如果有多个bean符合条件,则抛出错误。
- constructor:这个方式类似于byType, 但是要提供给构造器参数,如果没有确定的带参数的构造器参数类型,将会抛出异常。
- autodetect:首先尝试使用constructor来自动装配,如果无法工作,则使用byType方式。
34.自动装配有哪些局限性 ?
自动装配的局限性是:
- 重写: 你仍需用 <constructor-arg>和 <property> 配置来定义依赖,意味着总要重写自动装配。
- 基本数据类型:你不能自动装配简单的属性,如基本数据类型,String字符串,和类。
- 模糊特性:自动装配不如显式装配精确,如果有可能,建议使用显式装配。
35. 你可以在Spring中注入一个null 和一个空字符串吗?
可以。
Spring注解
36. 什么是基于Java的Spring注解配置? 给一些注解的例子.
基于Java的配置,允许你在少量的Java注解的帮助下,进行你的大部分Spring配置而非通过XML文件。
以@Configuration 注解为例,它用来标记类可以当做一个bean的定义,被Spring IOC容器使用。另一个例子是@Bean注解,它表示此方法将要返回一个对象,作为一个bean注册进Spring应用上下文。
37. 什么是基于注解的容器配置?
相对于XML文件,注解型的配置依赖于通过字节码元数据装配组件,而非尖括号的声明。
开发者通过在相应的类,方法或属性上使用注解的方式,直接组件类中进行配置,而不是使用xml表述bean的装配关系。
38. 怎样开启注解装配?
注解装配在默认情况下是不开启的,为了使用注解装配,我们必须在Spring配置文件中配置 <context:annotation-config/>元素。
39. @Required 注解
这个注解表明bean的属性必须在配置的时候设置,通过一个bean定义的显式的属性值或通过自动装配,若@Required注解的bean属性未被设置,容器将抛出BeanInitializationException。
40. @Autowired 注解
@Autowired 注解提供了更细粒度的控制,包括在何处以及如何完成自动装配。它的用法和@Required一样,修饰setter方法、构造器、属性或者具有任意名称和/或多个参数的PN方法。
41. @Qualifier 注解
当有多个相同类型的bean却只有一个需要自动装配时,将@Qualifier 注解和@Autowire 注解结合使用以消除这种混淆,指定需要装配的确切的bean。
Spring数据访问
42.在Spring框架中如何更有效地使用JDBC?
使用SpringJDBC 框架,资源管理和错误处理的代价都会被减轻。所以开发者只需写statements 和 queries从数据存取数据,JDBC也可以在Spring框架提供的模板类的帮助下更有效地被使用,这个模板叫JdbcTemplate (例子见这里here)
43. JdbcTemplate
JdbcTemplate 类提供了很多便利的方法解决诸如把数据库数据转变成基本数据类型或对象,执行写好的或可调用的数据库操作语句,提供自定义的数据错误处理。
44. Spring对DAO的支持
Spring对数据访问对象(DAO)的支持旨在简化它和数据访问技术如JDBC,Hibernate or JDO 结合使用。这使我们可以方便切换持久层。编码时也不用担心会捕获每种技术特有的异常。
45. 使用Spring通过什么方式访问Hibernate?
在Spring中有两种方式访问Hibernate:
- 控制反转 Hibernate Template和 Callback。
- 继承 HibernateDAOSupport提供一个AOP 拦截器。
46. Spring支持的ORM
Spring支持以下ORM:
- Hibernate
- iBatis
- JPA (Java Persistence API)
- TopLink
- JDO (Java Data Objects)
- OJB
47.如何通过HibernateDaoSupport将Spring和Hibernate结合起来?
用Spring的 SessionFactory 调用 LocalSessionFactory。集成过程分三步:
- 配置the Hibernate SessionFactory。
- 继承HibernateDaoSupport实现一个DAO。
- 在AOP支持的事务中装配。
48. Spring支持的事务管理类型
Spring支持两种类型的事务管理:
- 编程式事务管理:这意味你通过编程的方式管理事务,给你带来极大的灵活性,但是难维护。
- 声明式事务管理:这意味着你可以将业务代码和事务管理分离,你只需用注解和XML配置来管理事务。
49. Spring框架的事务管理有哪些优点?
- 它为不同的事务API 如 JTA,JDBC,Hibernate,JPA 和JDO,提供一个不变的编程模式。
- 它为编程式事务管理提供了一套简单的API而不是一些复杂的事务API如
- 它支持声明式事务管理。
- 它和Spring各种数据访问抽象层很好得集成。
50. 你更倾向用那种事务管理类型?
大多数Spring框架的用户选择声明式事务管理,因为它对应用代码的影响最小,因此更符合一个无侵入的轻量级容器的思想。声明式事务管理要优于编程式事务管理,虽然比编程式事务管理(这种方式允许你通过代码控制事务)少了一点灵活性。
Spring面向切面编程(AOP)
51. 解释AOP
面向切面的编程,或AOP, 是一种编程技术,允许程序模块化横向切割关注点,或横切典型的责任划分,如日志和事务管理。
52. Aspect 切面
AOP核心就是切面,它将多个类的通用行为封装成可重用的模块,该模块含有一组API提供横切功能。比如,一个日志模块可以被称作日志的AOP切面。根据需求的不同,一个应用程序可以有若干切面。在Spring AOP中,切面通过带有@Aspect注解的类实现。
52. 在Spring AOP 中,关注点和横切关注的区别是什么?
关注点是应用中一个模块的行为,一个关注点可能会被定义成一个我们想实现的一个功能。
横切关注点是一个关注点,此关注点是整个应用都会使用的功能,并影响整个应用,比如日志,安全和数据传输,几乎应用的每个模块都需要的功能。因此这些都属于横切关注点。
54. 连接点
连接点代表一个应用程序的某个位置,在这个位置我们可以插入一个AOP切面,它实际上是个应用程序执行Spring AOP的位置。
55. 通知
通知是个在方法执行前或执行后要做的动作,实际上是程序执行时要通过SpringAOP框架触发的代码段。
Spring切面可以应用五种类型的通知:
- before:前置通知,在一个方法执行前被调用。
- after: 在方法执行之后调用的通知,无论方法执行是否成功。
- after-returning: 仅当方法成功完成后执行的通知。
- after-throwing: 在方法抛出异常退出时执行的通知。
- around: 在方法执行之前和之后调用的通知。
56. 切点
切入点是一个或一组连接点,通知将在这些位置执行。可以通过表达式或匹配的方式指明切入点。
57. 什么是引入?
引入允许我们在已存在的类中增加新的方法和属性。
58. 什么是目标对象?
被一个或者多个切面所通知的对象。它通常是一个代理对象。也指被通知(advised)对象。
59. 什么是代理?
代理是通知目标对象后创建的对象。从客户端的角度看,代理对象和目标对象是一样的。
60. 有几种不同类型的自动代理?
BeanNameAutoProxyCreator
DefaultAdvisorAutoProxyCreator
Metadata autoproxying
61. 什么是织入。什么是织入应用的不同点?
织入是将切面和到其他应用类型或对象连接或创建一个被通知对象的过程。
织入可以在编译时,加载时,或运行时完成。
62. 解释基于XML Schema方式的切面实现。
在这种情况下,切面由常规类以及基于XML的配置实现。
63. 解释基于注解的切面实现
在这种情况下(基于@AspectJ的实现),涉及到的切面声明的风格与带有java5标注的普通java类一致。
Spring 的MVC
64. 什么是Spring的MVC框架?
Spring 配备构建Web 应用的全功能MVC框架。Spring可以很便捷地和其他MVC框架集成,如Struts,Spring 的MVC框架用控制反转把业务对象和控制逻辑清晰地隔离。它也允许以声明的方式把请求参数和业务对象绑定。
65. DispatcherServlet
Spring的MVC框架是围绕DispatcherServlet来设计的,它用来处理所有的HTTP请求和响应。
66. WebApplicationContext
WebApplicationContext 继承了ApplicationContext 并增加了一些WEB应用必备的特有功能,它不同于一般的ApplicationContext ,因为它能处理主题,并找到被关联的servlet。
67. 什么是Spring MVC框架的控制器?
控制器提供一个访问应用程序的行为,此行为通常通过服务接口实现。控制器解析用户输入并将其转换为一个由视图呈现给用户的模型。Spring用一个非常抽象的方式实现了一个控制层,允许用户创建多种用途的控制器。
68. @Controller 注解
该注解表明该类扮演控制器的角色,Spring不需要你继承任何其他控制器基类或引用Servlet API。
69. @RequestMapping 注解
该注解是用来映射一个URL到一个类或一个特定的方处理法上。
=============================================================================================
1、什么是 Spring Boot?
Spring Boot 是 Spring 开源组织下的子项目,是 Spring 组件一站式解决方案,主要是简化了使用 Spring 的难度,简省了繁重的配置,提供了各种启动器,开发者能快速上手。
更多 Spring Boot 详细介绍请看这篇文章《什么是Spring Boot?》。
2、为什么要用 Spring Boot?
Spring Boot 优点非常多,如:
- 独立运行
- 简化配置
- 自动配置
- 无代码生成和XML配置
- 应用监控
- 上手容易
- …
Spring Boot 集这么多优点于一身,还有理由不使用它呢?
3、Spring Boot 的核心配置文件有哪几个?它们的区别是什么?
Spring Boot 的核心配置文件是 application 和 bootstrap 配置文件。
application 配置文件这个容易理解,主要用于 Spring Boot 项目的自动化配置。
bootstrap 配置文件有以下几个应用场景。
- 使用 Spring Cloud Config 配置中心时,这时需要在 bootstrap 配置文件中添加连接到配置中心的配置属性来加载外部配置中心的配置信息;
- 一些固定的不能被覆盖的属性;
- 一些加密/解密的场景;
具体请看这篇文章《Spring Boot 核心配置文件详解》。
4、Spring Boot 的配置文件有哪几种格式?它们有什么区别?
.properties 和 .yml,它们的区别主要是书写格式不同。
1).properties
app.user.name = javastack
2).yml
app:
user:
name: javastack
另外,.yml 格式不支持 @PropertySource
注解导入配置。
5、Spring Boot 的核心注解是哪个?它主要由哪几个注解组成的?
启动类上面的注解是@SpringBootApplication,它也是 Spring Boot 的核心注解,主要组合包含了以下 3 个注解:
@SpringBootConfiguration:组合了 @Configuration 注解,实现配置文件的功能。
@EnableAutoConfiguration:打开自动配置的功能,也可以关闭某个自动配置的选项,如关闭数据源自动配置功能: @SpringBootApplication(exclude = { DataSourceAutoConfiguration.class })。
@ComponentScan:Spring组件扫描。
6、开启 Spring Boot 特性有哪几种方式?
1)继承spring-boot-starter-parent项目
2)导入spring-boot-dependencies项目依赖
具体请参考这篇文章《Spring Boot开启的2种方式》。
7、Spring Boot 需要独立的容器运行吗?
可以不需要,内置了 Tomcat/ Jetty 等容器。
8、运行 Spring Boot 有哪几种方式?
1)打包用命令或者放到容器中运行
2)用 Maven/ Gradle 插件运行
3)直接执行 main 方法运行
9、Spring Boot 自动配置原理是什么?
注解 @EnableAutoConfiguration, @Configuration, @ConditionalOnClass 就是自动配置的核心,首先它得是一个配置文件,其次根据类路径下是否有这个类去自动配置。
具体看这篇文章《Spring Boot自动配置原理、实战》。
10、Spring Boot 的目录结构是怎样的?
cn
+- javastack
+- MyApplication.java
|
+- customer
| +- Customer.java
| +- CustomerController.java
| +- CustomerService.java
| +- CustomerRepository.java
|
+- order
+- Order.java
+- OrderController.java
+- OrderService.java
+- OrderRepository.java
这个目录结构是主流及推荐的做法,而在主入口类上加上 @SpringBootApplication 注解来开启 Spring Boot 的各项能力,如自动配置、组件扫描等。具体看这篇文章《Spring Boot 主类及目录结构介绍》。
11、你如何理解 Spring Boot 中的 Starters?
Starters可以理解为启动器,它包含了一系列可以集成到应用里面的依赖包,你可以一站式集成 Spring 及其他技术,而不需要到处找示例代码和依赖包。如你想使用 Spring JPA 访问数据库,只要加入 spring-boot-starter-data-jpa 启动器依赖就能使用了。
Starters包含了许多项目中需要用到的依赖,它们能快速持续的运行,都是一系列得到支持的管理传递性依赖。具体请看这篇文章《Spring Boot Starters启动器》。
12、如何在 Spring Boot 启动的时候运行一些特定的代码?
可以实现接口 ApplicationRunner 或者 CommandLineRunner,这两个接口实现方式一样,它们都只提供了一个 run 方法,具体请看这篇文章《Spring Boot Runner启动器》。
13、Spring Boot 有哪几种读取配置的方式?
Spring Boot 可以通过 @PropertySource,@Value,@Environment, @ConfigurationProperties 来绑定变量,具体请看这篇文章《Spring Boot读取配置的几种方式》。
14、Spring Boot 支持哪些日志框架?推荐和默认的日志框架是哪个?
Spring Boot 支持 Java Util Logging, Log4j2, Lockback 作为日志框架,如果你使用 Starters 启动器,Spring Boot 将使用 Logback 作为默认日志框架,具体请看这篇文章《Spring Boot日志集成》。
15、SpringBoot 实现热部署有哪几种方式?
主要有两种方式:
- Spring Loaded
- Spring-boot-devtools
Spring-boot-devtools 使用方式可以参考这篇文章《Spring Boot实现热部署》。
16、你如何理解 Spring Boot 配置加载顺序?
在 Spring Boot 里面,可以使用以下几种方式来加载配置。
1)properties文件;
2)YAML文件;
3)系统环境变量;
4)命令行参数;
等等……
具体请看这篇文章《Spring Boot 配置加载顺序详解》。
17、Spring Boot 如何定义多套不同环境配置?
提供多套配置文件,如:
applcation.properties
application-dev.properties
application-test.properties
application-prod.properties
运行时指定具体的配置文件,具体请看这篇文章《Spring Boot Profile 不同环境配置》。
18、Spring Boot 可以兼容老 Spring 项目吗,如何做?
可以兼容,使用 @ImportResource
注解导入老 Spring 项目配置文件。
19、保护 Spring Boot 应用有哪些方法?
- 在生产中使用HTTPS
- 使用Snyk检查你的依赖关系
- 升级到最新版本
- 启用CSRF保护
- 使用内容安全策略防止XSS攻击
- …
更多请看这篇文章《10 种保护 Spring Boot 应用的绝佳方法》。
20、Spring Boot 2.X 有什么新特性?与 1.X 有什么区别?
- 配置变更
- JDK 版本升级
- 第三方类库升级
- 响应式 Spring 编程支持
- HTTP/2 支持
- 配置属性绑定
- 更多改进与加强…
具体请看这篇文章《Spring Boot 2.x 新特性总结及迁移指南》。
SpringBoot注解:
使用注解的优势:
1.采用纯java代码,不在需要配置繁杂的xml文件
2.在配置中也可享受面向对象带来的好处
3.类型安全对重构可以提供良好的支持
4.减少复杂配置文件的同时亦能享受到springIoC容器提供的功能
一、注解详解(配备了完善的释义)------(可采用ctrl+F 来进行搜索哦~~~~)
@SpringBootApplication:申明让spring boot自动给程序进行必要的配置,这个配置等同于:
@Configuration ,@EnableAutoConfiguration 和 @ComponentScan 三个配置。
@ResponseBody:表示该方法的返回结果直接写入HTTP response body中,一般在异步获取数据时使用,用于构建RESTful的api。在使用@RequestMapping后,返回值通常解析为跳转路径,加上@esponsebody后返回结果不会被解析为跳转路径,而是直接写入HTTP response body中。比如异步获取json数据,加上@Responsebody后,会直接返回json数据。该注解一般会配合@RequestMapping一起使用。
@Controller:用于定义控制器类,在spring项目中由控制器负责将用户发来的URL请求转发到对应的服务接口(service层),一般这个注解在类中,通常方法需要配合注解@RequestMapping。
@RestController:用于标注控制层组件(如struts中的action),@ResponseBody和@Controller的合集。
@RequestMapping:提供路由信息,负责URL到Controller中的具体函数的映射。
@EnableAutoConfiguration:SpringBoot自动配置(auto-configuration):尝试根据你添加的jar依赖自动配置你的Spring应用。例如,如果你的classpath下存在HSQLDB,并且你没有手动配置任何数据库连接beans,那么我们将自动配置一个内存型(in-memory)数据库”。你可以将@EnableAutoConfiguration或者@SpringBootApplication注解添加到一个@Configuration类上来选择自动配置。如果发现应用了你不想要的特定自动配置类,你可以使用@EnableAutoConfiguration注解的排除属性来禁用它们。
@ComponentScan:表示将该类自动发现扫描组件。个人理解相当于,如果扫描到有@Component、@Controller、@Service等这些注解的类,并注册为Bean,可以自动收集所有的Spring组件,包括@Configuration类。我们经常使用@ComponentScan注解搜索beans,并结合@Autowired注解导入。可以自动收集所有的Spring组件,包括@Configuration类。我们经常使用@ComponentScan注解搜索beans,并结合@Autowired注解导入。如果没有配置的话,Spring Boot会扫描启动类所在包下以及子包下的使用了@Service,@Repository等注解的类。
@Configuration:相当于传统的xml配置文件,如果有些第三方库需要用到xml文件,建议仍然通过@Configuration类作为项目的配置主类——可以使用@ImportResource注解加载xml配置文件。
@Import:用来导入其他配置类。
@ImportResource:用来加载xml配置文件。
@Autowired:自动导入依赖的bean
@Service:一般用于修饰service层的组件
@Repository:使用@Repository注解可以确保DAO或者repositories提供异常转译,这个注解修饰的DAO或者repositories类会被ComponetScan发现并配置,同时也不需要为它们提供XML配置项。
@Bean:用@Bean标注方法等价于XML中配置的bean。
@Value:注入Spring boot application.properties配置的属性的值。示例代码:
@Inject:等价于默认的@Autowired,只是没有required属性;
@Component:泛指组件,当组件不好归类的时候,我们可以使用这个注解进行标注。
@Bean:相当于XML中的,放在方法的上面,而不是类,意思是产生一个bean,并交给spring管理。
@AutoWired:自动导入依赖的bean。byType方式。把配置好的Bean拿来用,完成属性、方法的组装,它可以对类成员变量、方法及构造函数进行标注,完成自动装配的工作。当加上(required=false)时,就算找不到bean也不报错。
@Qualifier:当有多个同一类型的Bean时,可以用@Qualifier(“name”)来指定。与@Autowired配合使用。@Qualifier限定描述符除了能根据名字进行注入,但能进行更细粒度的控制如何选择候选者,具体使用方式如下:
@Resource(name=”name”,type=”type”):没有括号内内容的话,默认byName。与@Autowired干类似的事。
二、注解列表如下
@SpringBootApplication:包含了@ComponentScan、@Configuration和@EnableAutoConfiguration注解。其中
@ComponentScan:让spring Boot扫描到Configuration类并把它加入到程序上下文。
@Configuration :等同于spring的XML配置文件;使用Java代码可以检查类型安全。
@EnableAutoConfiguration :自动配置。
@ComponentScan :组件扫描,可自动发现和装配一些Bean。
@Component可配合CommandLineRunner使用,在程序启动后执行一些基础任务。
@RestController:注解是@Controller和@ResponseBody的合集,表示这是个控制器bean,并且是将函数的返回值直 接填入HTTP响应体中,是REST风格的控制器。
@Autowired:自动导入。
@PathVariable:获取参数。
@JsonBackReference:解决嵌套外链问题。
@RepositoryRestResourcepublic:配合spring-boot-starter-data-rest使用。
三、JPA注解
@Entity:@Table(name=”“):表明这是一个实体类。一般用于jpa这两个注解一般一块使用,但是如果表名和实体类名相同的话,@Table可以省略
@MappedSuperClass:用在确定是父类的entity上。父类的属性子类可以继承。
@NoRepositoryBean:一般用作父类的repository,有这个注解,spring不会去实例化该repository。
@Column:如果字段名与列名相同,则可以省略。
@Id:表示该属性为主键。
@GeneratedValue(strategy = GenerationType.SEQUENCE,generator = “repair_seq”):表示主键生成策略是sequence(可以为Auto、IDENTITY、native等,Auto表示可在多个数据库间切换),指定sequence的名字是repair_seq。
@SequenceGeneretor(name = “repair_seq”, sequenceName = “seq_repair”, allocationSize = 1):name为sequence的名称,以便使用,sequenceName为数据库的sequence名称,两个名称可以一致。
@Transient:表示该属性并非一个到数据库表的字段的映射,ORM框架将忽略该属性。如果一个属性并非数据库表的字段映射,就务必将其标示为@Transient,否则,ORM框架默认其注解为@Basic。@Basic(fetch=FetchType.LAZY):标记可以指定实体属性的加载方式
@JsonIgnore:作用是json序列化时将Java bean中的一些属性忽略掉,序列化和反序列化都受影响。
@JoinColumn(name=”loginId”):一对一:本表中指向另一个表的外键。一对多:另一个表指向本表的外键。
@OneToOne、@OneToMany、@ManyToOne:对应hibernate配置文件中的一对一,一对多,多对一。
四、springMVC相关注解
@RequestMapping:@RequestMapping(“/path”)表示该控制器处理所有“/path”的UR L请求。RequestMapping是一个用来处理请求地址映射的注解,可用于类或方法上。
用于类上,表示类中的所有响应请求的方法都是以该地址作为父路径。该注解有六个属性:
params:指定request中必须包含某些参数值是,才让该方法处理。
headers:指定request中必须包含某些指定的header值,才能让该方法处理请求。
value:指定请求的实际地址,指定的地址可以是URI Template 模式
method:指定请求的method类型, GET、POST、PUT、DELETE等
consumes:指定处理请求的提交内容类型(Content-Type),如application/json,text/html;
produces:指定返回的内容类型,仅当request请求头中的(Accept)类型中包含该指定类型才返回
@RequestParam:用在方法的参数前面。
@RequestParam
String a =request.getParameter(“a”)。
@PathVariable:路径变量。如
参数与大括号里的名字一样要相同。
五、全局异常处理
@ControllerAdvice:包含@Component。可以被扫描到。统一处理异常。
@ExceptionHandler(Exception.class):用在方法上面表示遇到这个异常就执行以下方法。
六、项目中具体配置解析和使用环境
@MappedSuperclass:
1.@MappedSuperclass 注解使用在父类上面,是用来标识父类的
2.@MappedSuperclass 标识的类表示其不能映射到数据库表,因为其不是一个完整的实体类,但是它所拥有的属性能够映射在其子类对用的数据库表中
3.@MappedSuperclass 标识的类不能再有@Entity或@Table注解
@Column:
1.当实体的属性与其映射的数据库表的列不同名时需要使用@Column标注说明,该属性通常置于实体的属性声明语句之前,还可与 @Id 标注一起使用。
2.@Column 标注的常用属性是name,用于设置映射数据库表的列名。此外,该标注还包含其它多个属性,如:unique、nullable、length、precision等。具体如下:
1 name属性:name属性定义了被标注字段在数据库表中所对应字段的名称
2 unique属性:unique属性表示该字段是否为唯一标识,默认为false,如果表中有一个字段需要唯一标识,则既可以使用该标记,也可以使用@Table注解中的@UniqueConstraint
3 nullable属性:nullable属性表示该字段是否可以为null值,默认为true
4 insertable属性:insertable属性表示在使用”INSERT”语句插入数据时,是否需要插入该字段的值
5 updateable属性:updateable属性表示在使用”UPDATE”语句插入数据时,是否需要更新该字段的值
6 insertable和updateable属性:一般多用于只读的属性,例如主键和外键等,这些字段通常是自动生成的
7 columnDefinition属性:columnDefinition属性表示创建表时,该字段创建的SQL语句,一般用于通过Entity生成表定义时使用,如果数据库中表已经建好,该属性没有必要使用
8 table属性:table属性定义了包含当前字段的表名
9 length属性:length属性表示字段的长度,当字段的类型为varchar时,该属性才有效,默认为255个字符
10 precision属性和scale属性:precision属性和scale属性一起表示精度,当字段类型为double时,precision表示数值的总长度,scale表示小数点所占的位数
具体如下:
1.double类型将在数据库中映射为double类型,precision和scale属性无效
2.double类型若在columnDefinition属性中指定数字类型为decimal并指定精度,则最终以columnDefinition为准
3.BigDecimal类型在数据库中映射为decimal类型,precision和scale属性有效
4.precision和scale属性只在BigDecimal类型中有效
3.@Column 标注的columnDefinition属性: 表示该字段在数据库中的实际类型.通常 ORM 框架可以根据属性类型自动判断数据库中字段的类型,但是对于Date类型仍无法确定数据库中字段类型究竟是DATE,TIME还是TIMESTAMP.此外,String的默认映射类型为VARCHAR,如果要将 String 类型映射到特定数据库的 BLOB 或TEXT字段类型.
4.@Column标注也可置于属性的getter方法之前
@Getter和@Setter(Lombok)
@Setter:注解在属性上;为属性提供 setting 方法 @Getter:注解在属性上;为属性提供 getting 方法
1 @Data:注解在类上;提供类所有属性的 getting 和 setting 方法,此外还提供了equals、canEqual、hashCode、toString 方法
2
3 @Setter:注解在属性上;为属性提供 setting 方法
4
5 @Getter:注解在属性上;为属性提供 getting 方法
6
7 @Log4j2 :注解在类上;为类提供一个 属性名为log 的 log4j 日志对象,和@Log4j注解类似
8
9 @NoArgsConstructor:注解在类上;为类提供一个无参的构造方法
10
11 @AllArgsConstructor:注解在类上;为类提供一个全参的构造方法
12
13 @EqualsAndHashCode:默认情况下,会使用所有非瞬态(non-transient)和非静态(non-static)字段来生成equals和hascode方法,也可以指定具体使用哪些属性。
14
15 @toString:生成toString方法,默认情况下,会输出类名、所有属性,属性会按照顺序输出,以逗号分割。
16
17 @NoArgsConstructor, @RequiredArgsConstructor and @AllArgsConstructor
18 无参构造器、部分参数构造器、全参构造器,当我们需要重载多个构造器的时候,只能自己手写了
19
20 @NonNull:注解在属性上,如果注解了,就必须不能为Null
21
22 @val:注解在属性上,如果注解了,就是设置为final类型,可查看源码的注释知道
当你在执行各种持久化方法的时候,实体的状态会随之改变,状态的改变会引发不同的生命周期事件。这些事件可以使用不同的注释符来指示发生时的回调函数。
@javax.persistence.PostLoad:加载后。
@javax.persistence.PrePersist:持久化前。
@javax.persistence.PostPersist:持久化后。
@javax.persistence.PreUpdate:更新前。
@javax.persistence.PostUpdate:更新后。
@javax.persistence.PreRemove:删除前。
@javax.persistence.PostRemove:删除后。
1)数据库查询
@PostLoad事件在下列情况下触发:
执行EntityManager.find()或getreference()方法载入一个实体后。
执行JPQL查询后。
EntityManager.refresh()方法被调用后。
2)数据库插入
@PrePersist和@PostPersist事件在实体对象插入到数据库的过程中发生:
@PrePersist事件在调用persist()方法后立刻发生,此时的数据还没有真正插入进数据库。
@PostPersist事件在数据已经插入进数据库后发生。
3)数据库更新
@PreUpdate和@PostUpdate事件的触发由更新实体引起:
@PreUpdate事件在实体的状态同步到数据库之前触发,此时的数据还没有真正更新到数据库。
@PostUpdate事件在实体的状态同步到数据库之后触发,同步在事务提交时发生。
4)数据库删除
@PreRemove和@PostRemove事件的触发由删除实体引起:
@PreRemove事件在实体从数据库删除之前触发,即在调用remove()方法删除时发生,此时的数据还没有真正从数据库中删除。
@PostRemove事件在实体从数据库中删除后触发。