澳门新浦京娱乐游戏spring-boot 注解

澳门新浦京娱乐游戏 3

开发企业应用时我们常常遇到要同时访问多种不同数据库的问题,有时是必须把数据归档到某种数据仓库中,有时是要把数据变更推送到第三方数据库中。使用Spring框架时,使用单一数据库是非常容易的,但如果要同时访问多个数据库的话事件就变得复杂多了。

在Maven依赖中引入了spring-boot-starter-web,它包含了Spring
Boot预定义的一些Web开发的常用依赖:

spring-boot使用了大量的注解来进行开发,

本文以在Spring框架下开发一个SpringMVC程序为例,示范了一种同时访问多种数据库的方法,而且尽量地简化配置改动。

spring-web,spring-webmvcSpring
WebMvc框架
tomcat-embed-*内嵌Tomcat容器
jackson处理json数据
spring-*Spring框架
spring-boot-autoconfigureSpring Boot提供的自动配置功能

Application类,是spring-boot的启动类,

搭建数据库

建议你也同时搭好两个数据库来跟进我们的示例。本文中我们用了PostgreSQL和MySQL。

下面的脚本内容是在两个数据库中建表和插入数据的命令。

PostgreSQL

CREATE TABLE usermaster ( 
   id integer, 
   name character varying, 
   emailid character varying, 
   phoneno character varying(10), 
   location character varying
) 

INSERT INTO usermaster(id, name, emailid, phoneno, location)
VALUES (1, 'name_postgres', 'email@email.com', '1234567890', 'IN');

MySQL

CREATE TABLE `usermaster` (
   `id` int(11) NOT NULL, 
   `name` varchar(255) DEFAULT NULL, 
   `emailid` varchar(20) DEFAULT NULL, 
   `phoneno` varchar(20) DEFAULT NULL, 
   `location` varchar(20) DEFAULT NULL, 
   PRIMARY KEY (`id`) 
)

INSERT INTO `kode12`.`usermaster` 
  (`id`, `name`, `emailid`, `phoneno`, `location`)
VALUES
  ('1', 'name_mysql', 'test@tset.com', '9876543210', 'IN');

Java代码中没有任何配置,和传统的Spring应用相比,多了两个我们不认识的符号:

@SpringBootApplication 申明让spring
boot自动给程序进行必要的配置等同于:@Configuration
,@EnableAutoConfiguration 和 @ComponentScan
三个配置。其中@ComponentScan让spring
Boot扫描到Configuration类并把它加入到程序上下文。

搭建项目

我们用Spring Tool Suite (STS)来构建这个例子:

  • 点击File -> New -> Spring Starter Project。
  • 在对话框中输入项目名、Maven坐标、描述和包信息等,点击Next。
  • 在boot dependency中选择Web,点击Next。
  • 点击Finish。STS会自动按照项目依赖关系从Spring仓库中下载所需要的内容。

创建完的项目如下图所示:

澳门新浦京娱乐游戏 1

接下来我们仔细研究一下项目中的各个相关文件内容。

pom.xml

pom中包含了所有需要的依赖和插件映射关系。

代码:

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" 
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 
    http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.aegis</groupId>
    <artifactId>MultipleDBConnect</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>jar</packaging>

    <name>MultipleDB</name>
    <description>MultipleDB with Spring Boot</description>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.3.5.RELEASE</version>
        <relativePath />
    </parent>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </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-jdbc</artifactId>
        </dependency>

        <dependency>
            <groupId>org.postgresql</groupId>
            <artifactId>postgresql</artifactId>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.38</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

解释:

下面详细解释各种依赖关系的细节:

  • spring-boot-starter-web:为Web开发和MVC提供支持。
  • spring-boot-starter-test:提供JUnit、Mockito等测试依赖。
  • spring-boot-starter-jdbc:提供JDBC支持。
  • postgresql:PostgreSQL数据库的JDBC驱动。
  • mysql-connector-java:MySQL数据库的JDBC驱动。

application.properties

包含程序需要的所有配置信息。在旧版的Spring中我们要通过多个XML文件来提供这些配置信息。

server.port=6060
spring.ds_post.url =jdbc:postgresql://localhost:5432/kode12
spring.ds_post.username =postgres
spring.ds_post.password =root
spring.ds_post.driverClassName=org.postgresql.Driver
spring.ds_mysql.url = jdbc:mysql://localhost:3306/kode12
spring.ds_mysql.username = root
spring.ds_mysql.password = root
spring.ds_mysql.driverClassName=com.mysql.jdbc.Driver

解释:

“server.port=6060”声明你的嵌入式服务器启动后会使用6060端口(port.server.port是Boot默认的标准端口)。

其他属性中:

  • 以“spring.ds_*”为前缀的是用户定义属性。
  • 以“spring.ds_post.*”为前缀的是为PostgreSQL数据库定义的属性。
  • 以“spring.ds_mysql.*”为前缀的是为MySQL数据库定义的属性。

MultipleDbApplication.java

package com.aegis;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public MultipleDbApplication {

    public static void main(String[] args) {
        SpringApplication.run(MultipleDbApplication.class, args);
    }
}

这个文件包含了启动我们的Boot程序的主函数。注解“@SpringBootApplication”是所有其他Spring注解和Java注解的组合,包括:

@Configuration
@EnableAutoConfiguration
@ComponentScan
@Target(value={TYPE})
@Retention(value=RUNTIME)
@Documented
@Inherited

其他注解:

@Configuration
@EnableAutoConfiguration
@ComponentScan

上述注解会让容器通过这个类来加载我们的配置。

MultipleDBConfig.java

package com.aegis.config;
import javax.sql.DataSource;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.autoconfigure.jdbc.DataSourceBuilder;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.jdbc.core.JdbcTemplate;

@Configuration
public class MultipleDBConfig {
    @Bean(name = "mysqlDb")
    @ConfigurationProperties(prefix = "spring.ds_mysql")
    public DataSource mysqlDataSource() {
        return DataSourceBuilder.create().build();
    }

    @Bean(name = "mysqlJdbcTemplate")
    public JdbcTemplate jdbcTemplate(@Qualifier("mysqlDb") DataSource dsMySQL) {
        return new JdbcTemplate(dsMySQL);
    }

    @Bean(name = "postgresDb")
    @ConfigurationProperties(prefix = "spring.ds_post")
    public DataSource postgresDataSource() {
        return  DataSourceBuilder.create().build();
    }

    @Bean(name = "postgresJdbcTemplate")
    public JdbcTemplate postgresJdbcTemplate(@Qualifier("postgresDb") 
                                              DataSource dsPostgres) {
        return new JdbcTemplate(dsPostgres);
    }
}

解释:

这是加了注解的配置类,包含加载我们的PostgreSQL和MySQL数据库配置的函数和注解。这也会负责为每一种数据库创建JDBC模板类。

下面我们看一下这四个函数:

@Bean(name = "mysqlDb")
@ConfigurationProperties(prefix = "spring.ds_mysql")
public DataSource mysqlDataSource() {
return DataSourceBuilder.create().build();
}

上面代码第一行创建了mysqlDb bean。
第二行帮助@Bean加载了所有有前缀spring.ds_mysql的属性。
第四行创建并初始化了DataSource类,并创建了mysqlDb DataSource对象。

@Bean(name = "mysqlJdbcTemplate")
public JdbcTemplate jdbcTemplate(@Qualifier("mysqlDb") DataSource dsMySQL) {
     return new JdbcTemplate(dsMySQL);
}

第一行以mysqlJdbcTemplate为名创建了一个JdbcTemplate类型的新Bean。
第二行将第一行中创建的DataSource类型新参数传入函数,并以mysqlDB为qualifier。
第三行用DataSource对象初始化JdbcTemplate实例。

@Bean(name = "postgresDb")
@ConfigurationProperties(prefix = "spring.ds_post")
public DataSource postgresDataSource() {
   return  DataSourceBuilder.create().build();
}

第一行创建DataSource实例postgresDb。
第二行帮助@Bean加载所有以spring.ds_post为前缀的配置。
第四行创建并初始化DataSource实例postgresDb。

@Bean(name = "postgresJdbcTemplate")
public JdbcTemplate postgresJdbcTemplate(@Qualifier("postgresDb")
                                          DataSource dsPostgres) {
  return new JdbcTemplate(dsPostgres);
}

第一行以postgresJdbcTemplate为名创建JdbcTemplate类型的新bean。
第二行接受DataSource类型的参数,并以postgresDb为qualifier。
第三行用DataSource对象初始化JdbcTemplate实例。

DemoController.java

package com.aegis.controller;
import java.util.HashMap;
import java.util.Map;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class DemoController {

    @Autowired
    @Qualifier("postgresJdbcTemplate")
    private JdbcTemplate postgresTemplate;

    @Autowired
    @Qualifier("mysqlJdbcTemplate")
    private JdbcTemplate mysqlTemplate;

    @RequestMapping(value = "/getPGUser")
    public String getPGUser() {
        Map<String, Object> map = new HashMap<String, Object>();
        String query = " select * from usermaster";
        try {
            map = postgresTemplate.queryForMap(query);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return "PostgreSQL Data: " + map.toString();
    }

    @RequestMapping(value = "/getMYUser")
    public String getMYUser() {
        Map<String, Object> map = new HashMap<String, Object>();
        String query = " select * from usermaster";
        try {
            map = mysqlTemplate.queryForMap(query);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return "MySQL Data: " + map.toString();
    }
}

解释:

@RestController类注解表明这个类中定义的所有函数都被默认绑定到响应中。

上面代码段创建了一个JdbcTemplate实例。@Qualifier用于生成一个对应类型的模板。代码中提供的是postgresJdbcTemplate作为Qualifier参数,所以它会加载MultipleDBConfig实例的jdbcTemplate(…)函数创建的Bean。

这样Spring就会根据你的要求来调用合适的JDBC模板。在调用URL
“/getPGUser”时Spring会用PostgreSQL模板,调用URL
“/getMYUser”时Spring会用MySQL模板。

@Autowired
@Qualifier("postgresJdbcTemplate")
private JdbcTemplate postgresTemplate;

这里我们用queryForMap(String
query)函数来使用JDBC模板从数据库中获取数据,queryForMap(…)返回一个map,以字段名为Key,Value为实际字段值。

@EnableAutoConfiguration
SpringApplication

@SpringBootApplication

演示

执行类MultipleDbApplication中的main
(…)函数就可以看到演示效果。在你常用的浏览器中点击下面URL:

URL: 

上面的URL会查询MySQL数据库并以字符串形式返回数据。

澳门新浦京娱乐游戏 2

Url: 

上面的URL会查询PostgreSQL数据库并以字符串形式返回数据。

澳门新浦京娱乐游戏 3

它们都是由Spring
Boot框架提供。在SpringApplication.run()方法执行后,Spring
Boot的autoconfigure发现这是一个Web应用(根据类路径上的依赖确定),于是在内嵌的Tomcat容器中启动了一个Spring的应用上下文,并且监听默认的tcp端口8080(默认约定)。同时在Spring
Context中根据默认的约定配置了Spring WebMvc:

public class FeedApplication {

关于作者

Aaron Jacobson是个经验丰富的Java Web程序员,在外包与咨询公司Technoligent担任Java开发程序员10年以上。他的主要贡献包括Java、Python、Asp.Net和手机应用等一系列Web解决方案。可以通过Twitter
@Techno_Ligent或Facebook @TechnoLigent联系他。

Servlet容器默认的Context路径是/
DispatherServlet匹配的路径(servlet-mapping中的url-patterns)是/*
@ComponentScan路径被默认设置为SampleController的同名package,也就是该package下的所有@Controller,@Service,@Component,@Repository都会被实例化后并加入Spring
Context中。

public static void main(String[] args) {

没有一行配置代码、也没有web.xml。基于Spring
Boot的应用在大多数情况下都不需要我们去显式地声明各类配置,而是将最常用的默认配置作为约定,在不声明的情况下也能适应大多数的开发场景。

SpringApplication.run(FeedApplication.class, args);

实例:数据库访问

除了最基本的Web框架,另一种非常普遍的开发场景是访问数据库。在传统的Spring应用中,访问数据库我们需要配置:

类路径上添加数据库访问驱动
实例化DataSource对象,指定数据库url,username,password等信息
注入JdbcTemplate对象,如果使用Hibernate,Mybatis等框架,还需要进一步配置框架信息

在Spring Boot中,上述过程会被简化。首先在Maven项目依赖中定义:

    org.springframework.boot
    spring-boot-starter-web-jdbc


    com.h2database
    h2

spring-boot-starter-web-jdbc引入了spring-jdbc依赖,h2是一个内存关系型数据库。在引入了这些依赖并启动Spring
Boot应用程序后,autoconfigure发现spring-jdbc位于类路径中,于是:

根据类路径上的JDBC驱动类型(这里是h2,预定义了derby,sqlite,mysql,oracle,sqlserver等等),创建一个DataSource连接池对象,本例中的h2是内存数据库,无需任何配置,如果是mysql,oracle等类型的数据库需要开发者配置相关信息。
在Spring Context中创建一个JdbcTemplate对象(使用DataSource初始化)

接下来开发者的工作就非常简单了,在业务逻辑中直接引入JdbcTemplate即可:

@Service
public class MyService {

    @Autowired
    JdbcTemplate jdbcTemplate;

}

除了spring-jdbc,Spring
Boot还能够支持JPA,以及各种NoSQL数据库——包括MongoDB,Redis,全文索引工具elasticsearch,solr等等。

}

配置

Spring
Boot最大的特色是“约定优先配置”,大量的默认配置对开发者十分的友好。但是在实际的应用开发过程中,默认配置不可能满足所有场景,同时用户也需要配置一些必须的配置项——例如数据库连接信息。Spring
Boot的配置系统能够让开发者快速的覆盖默认约定,同时支持Properties配置文件和YAML配置文件两种格式,默认情况下Spring
Boot加载类路径上的application.properties或application.yml文件,例如:

spring.datasource.url=jdbc:postgresql://localhost/test
spring.datasource.username=postgres
spring.datasource.password=1234
spring.datasource.driver-class-name=org.postgresql.Driver

通过port和address可以修改服务器监听的地址和端口,sessionTimeout配置session过期时间(再也不用修改web.xml了,因为它根本不存在)。同时如果在生产环境中使用内嵌Tomcat,当然希望能够配置它的日志、线程池等信息,这些现在都可以通过Spring
Boot的属性文件配置,而不再需要再对生产环境中的Tomcat实例进行单独的配置管理了。

}

@EnableAutoCongiguration

从Spring
3.0开始,为了替代繁琐的XML配置,引入了@Enable…注解对@Configuration类进行修饰以达到和XML配置相同的效果。想必不少开发者已经使用过类似注解:

@EnableTransactionManagement开启Spring事务管理,相当于XMl中的
@EnableWebMvc使用Spring MVC框架的一些默认配置
@EnableScheduling会初始化一个Scheduler用于执行定时任务和异步任务

Spring
Boot提供的@EnableAutoCongiguration似乎功能更加强大,一旦加上,上述所有的配置似乎都被包含进来而无需开发者显式声明。它究竟是如何做到的呢,先看看它的定义:

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import({ EnableAutoConfigurationImportSelector.class,
        AutoConfigurationPackages.Registrar.class })
public @interface EnableAutoConfiguration {

    /**
     * Exclude specific auto-configuration classes such that they will never be applied.
     */
    Class[] exclude() default {};

}

EnableAutoConfigurationImportSelector使用的是spring-core模块中的SpringFactoriesLoader#loadFactoryNames()方法,它的作用是在类路径上扫描META-INF/spring.factories文件中定义的类:

 

# Initializers
org.springframework.context.ApplicationContextInitializer=
org.springframework.boot.autoconfigure.logging.AutoConfigurationReportLoggingInitializer

# Auto Configure
org.springframework.boot.autoconfigure.EnableAutoConfiguration=
org.springframework.boot.autoconfigure.aop.AopAutoConfiguration,
org.springframework.boot.autoconfigure.amqp.RabbitAutoConfiguration,
org.springframework.boot.autoconfigure.MessageSourceAutoConfiguration,
org.springframework.boot.autoconfigure.PropertyPlaceholderAutoConfiguration,
org.springframework.boot.autoconfigure.batch.BatchAutoConfiguration,
org.springframework.boot.autoconfigure.data.JpaRepositoriesAutoConfiguration,
org.springframework.boot.autoconfigure.data.MongoRepositoriesAutoConfiguration,
org.springframework.boot.autoconfigure.redis.RedisAutoConfiguration,
org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration,
org.springframework.boot.autoconfigure.jdbc.DataSourceTransactionManagerAutoConfiguration,
org.springframework.boot.autoconfigure.jms.JmsTemplateAutoConfiguration,
org.springframework.boot.autoconfigure.jmx.JmxAutoConfiguration,
org.springframework.boot.autoconfigure.mobile.DeviceResolverAutoConfiguration,
org.springframework.boot.autoconfigure.mongo.MongoAutoConfiguration,
org.springframework.boot.autoconfigure.mongo.MongoTemplateAutoConfiguration,
org.springframework.boot.autoconfigure.orm.jpa.HibernateJpaAutoConfiguration,
org.springframework.boot.autoconfigure.reactor.ReactorAutoConfiguration,
org.springframework.boot.autoconfigure.security.SecurityAutoConfiguration,
org.springframework.boot.autoconfigure.security.FallbackWebSecurityAutoConfiguration,
org.springframework.boot.autoconfigure.thymeleaf.ThymeleafAutoConfiguration,
org.springframework.boot.autoconfigure.web.EmbeddedServletContainerAutoConfiguration,
org.springframework.boot.autoconfigure.web.DispatcherServletAutoConfiguration,
org.springframework.boot.autoconfigure.web.ServerPropertiesAutoConfiguration,
org.springframework.boot.autoconfigure.web.MultipartAutoConfiguration,
org.springframework.boot.autoconfigure.web.HttpMessageConvertersAutoConfiguration,
org.springframework.boot.autoconfigure.web.WebMvcAutoConfiguration,
org.springframework.boot.autoconfigure.websocket.WebSocketAutoConfiguration

实际上这就是Spring
Boot会自动配置的一些对象,例如前面提到的Web框架由EmbeddedServletContainerAutoConfiguration,DispatcherServletAutoConfiguration,ServerPropertiesAutoConfiguration等配置完成,而DataSource的自动配置则是由DataSourceAutoConfiguration完成。现在我们以Mongo的配置MongoAutoConfiguration为例,来探索Spring
Boot是如何完成这些配置的:

@Configuration
@ConditionalOnClass(Mongo.class)
@EnableConfigurationProperties(MongoProperties.class)
public class MongoAutoConfiguration {

    @Autowired
    private MongoProperties properties;

    private Mongo mongo;

    @PreDestroy
    public void close() throws UnknownHostException {
        if (this.mongo != null) {
            this.mongo.close();
        }
    }

    @Bean
    @ConditionalOnMissingBean
    public Mongo mongo() throws UnknownHostException {
        this.mongo = this.properties.createMongoClient();
        return this.mongo;
    }

}

首先这是一个Spring的配置@Configuration,它定义了我们访问Mongo需要的@Bean,如果这个@Configuration被Spring
Context扫描到,那么Context中自然也就有两个一个Mongo对象能够直接为开发者所用。

但是注意到其它几个Spring注解:

@ConditionOnClass表明该@Configuration仅仅在一定条件下才会被加载,这里的条件是Mongo.class位于类路径上
@EnableConfigurationProperties将Spring
Boot的配置文件(application.properties)中的spring.data.mongodb.*属性映射为MongoProperties并注入到MongoAutoConfiguration中。
@ConditionalOnMissingBean说明Spring
Boot仅仅在当前上下文中不存在Mongo对象时,才会实例化一个Bean。这个逻辑也体现了Spring
Boot的另外一个特性——自定义的Bean优先于框架的默认配置,我们如果显式的在业务代码中定义了一个Mongo对象,那么Spring
Boot就不再创建。

接下来看一看MongoProperties:

@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
}

显然,它就是以spring.data.mongodb作为前缀的属性,然后通过名字直接映射为对象的属性,同时还包含了一些默认值。如果不配置,那么mongo.uri就是mongodb://localhost/test。

SpringApplication.run(FeedApplication.class, args);

Production特性

从前面的例子可以看出,Spring
Boot能够非常快速的做出一些原型应用,但是它同样可以被用于生产环境。为了添加生产环境特性支持,需要在Maven依赖中引入:

    org.springframework.boot
    spring-boot-starter-actuator

加入actuator依赖后,应用启动后会创建一些基于Web的Endpoint:

/autoconfig,用来查看Spring
Boot的框架自动配置信息,哪些被自动配置,哪些没有,原因是什么。
/beans,显示应用上下文的Bean列表
/dump,显示线程dump信息
/health,应用健康状况检查
/metrics
/shutdown, 默认没有打开
/trace

该方法就是用来启动项目的。

@Configuration 等同于spring的XML配置文件;使用Java代码可以检查类型安全。

示例代码:

@Configuration

@PropertySource(“classpath:/database.properties”)

public class DataBaseConfig {

@Bean

@ConfigurationProperties(prefix = “notice.datasource”)

public DataSource noticeDataSource() {

return DataSourceBuilder.create().build();

}

@Bean

public JdbcTemplate noticeJDBCTemplate() {

return new JdbcTemplate(noticeDataSource());

}

}

这个就是用来配置数据库的配置。添加@Configuration 以后,
spring-boot启动的时候,就会自动识别这个使用配置文件,然后就会自动加载配置。

@PropertySource(“classpath:/database.properties”)这个是用来定于配置文件的位置,如果没有添加这个注解的话,就会默认去application.ConfigurationPropertie中进行查找。

@Controller:用于定义控制器类,在spring 项目中由控制器负责将用户发来的

URL请求转发到对应的服务接口(service层),一般这个注解在类中,

通常方法需要配合注解@RequestMapping(提供路由信息,负责URL到Controller

中的具体函数的映射)。

示例代码:

@Controller

@RequestMapping(“/feed/notice”)

public class FeedController {

@Autowired ()

private FeedGetService feedGetService;

@Autowired

private FeedPublishService publishService;

/**

* 获取用户的个人消息以及系统消息的条数

*/

@RequestMapping(“/getNoticeNum”)

@ResponseBody

public Object getNoticeNum(@RequestParam final String user,
@RequestParam final String locale,

@RequestParam final String area, @RequestParam final String channel,

@RequestParam final String version) {

GetUserNoticeNum userNoticeNum = feedGetService.getNoticeNum(user,
locale, area, channel, version);

return new ResponseResult<>(userNoticeNum).success();

}

}

@EnableAutoConfiguration 自动配置。

Spring
Boot自动配置(auto-configuration):尝试根据你添加的jar依赖自动配置你的

Spring 应用。例如,如果你的classpath下存在HSQLDB,

并且你没有手动配置任何数据库连接beans,

那么我们将自动配置一个内存型(in-memory)数据库”。

你可以将@EnableAutoConfiguration 或者@SpringBootApplication

注解添加到一个@Configuration 类上来选择自动配置。如果发现应用了你

不想要的特定自动配置类,你可以使用@EnableAutoConfiguration

注解的排除属性来禁用它们

@ComponentScan 组件扫描,可自动发现和装配一些Bean。

表示将该类自动发现扫描组件。如果扫描到有@Component、@Controller、@Service
等这些注解的类,并注册为Bean,

可以自动收集所有的Spring组件,包括@Configuration类。

我们经常使用@ComponentScan 注解搜索beans,并结合@Autowired 注解导入。

如果没有配置的话,Spring Boot 会扫描启动类所在包下以及子

包下的使用了@Service,@Repository
等注解的类。(我的项目中就没有进行配置。)

@Component 可配合CommandLineRunner使用,在程序启动后执行一些基础任务。

@RestController 注解是 @Controller 和 @ResponseBody 的合集,

表示这是个控制器bean,并且是将函数的返回值直

接填入HTTP响应体中,是REST风格的控制器。

@Autowired:自动导入依赖的bean
。把配置好的Bean拿来用,完成属性、方法的组装,

它可以对类成员变量、方法及构造函数进行标注,完成自动装配的工作。

当加上(required=false)时,就算找不到bean也不报错。

@Component:泛指组件,当组件不好归类的时候,我们可以使用这个注解进行标注。

@Service:一般用于修饰service层的组件

@Bean:用@Bean 标注方法等价于XML中配置的bean。放在方法的上面,而不是类,

意思是产生一个bean,并交给spring管理。

@PathVariable 获取参数。

@Value:注入Spring boot application.properties配置的属性的值。

示例代码:

@Value(“${send.sms.byecomm}”)

private String sendSMSByEcomm;

application.properties配置文件中配置的是
send.sms.byecomm=

spring boot
就会自动将值赋给sendSMSByEcomm,我们调用sendSMSByEcomm就可以了。

@Repository:使用@Repository 注解可以确保DAO或者repositories
提供异常转译,

这个注解修饰的DAO或者repositories类会被ComponetScan发现并配置,

同时也不需要为它们提供XML配置项。

示例代码:

@Repository

public class FeedRedisDao {

@Resource

private StringRedisTemplate feedRedisTemplate;

public void setGetSysNotice(String user, int noticeId, int day) {

String key = “getSysNotice_” + user + “_” + noticeId;

feedRedisTemplate.opsForValue().set(key, user, day, TimeUnit.DAYS);

}

}

@Qualifier:当有多个同一类型的Bean时,可以用@Qualifier(“name”)来指定。

与@Autowired 配合使用。@Qualifier 限定描述符除了能根据名字进行注入,

但能进行更细粒度的控制如何选择候选者,具体使用方式如下:

示例代码:

@Configuration

@PropertySource(“classpath:/database.properties”)

public class DataBaseConfig {

@Bean(name = “npsDataSource”)

@Primary

@ConfigurationProperties(prefix = “integration.datasource”)

public DataSource npsDataSource() {

return DataSourceBuilder.create().build();

}

@Bean(name = “npsJDBCTemplate”)

public JdbcTemplate npsJDBCTemplate(@Qualifier(“npsDataSource”)
DataSource npsDataSource) {

return new JdbcTemplate(npsDataSource);

}

@Bean(name = “iranDataSource”)

@ConfigurationProperties(prefix = “iran.datasource”)

public DataSource iranDataSource() {

return DataSourceBuilder.create().build();

}

@Bean(name = “iranJDBCTemplate”)

public JdbcTemplate iranJDBCTemplate(@Qualifier(“iranDataSource”)
DataSource iranDataSource) {

return new JdbcTemplate(iranDataSource);

}

}

示例代码中展示的是两个数据的配置,为了能让数据库加载正确,所以每一个bean都定义了名称。

spring-boot启动的时候会默认加载一个数据库配置,但是配置两个的时候spring-boot

就会不知道该加载那个数据库而报错,所以需要@Primary 注解,@Primary
表示默认加载

哪一个配置。这样在启动的时候就会默认加载npsDataSource这个数据库,然后当你使用iranDataSource

的时候就会自动加载进来,

@Resource(name=”name”,type=”type”):与@Autowired 干类似的事

对于spring-boot 的配置文件有.yml和.properties两种,

.yml的写法

server:

port: 8080

address: localhost

iran:

datasource:

url: dbc:mysql://localhost:3306/asset

username: root

password: root

.properties的写法

server.port=8080

iran.datasource.url=jdbc:mysql://localhost:3306/asset

iran.datasource.username=root

iran.datasource.password=root

You can leave a response, or trackback from your own site.

Leave a Reply

网站地图xml地图