如何在Java容器中配置springboot

如何在Java容器中配置spring boot？針對這個問題，這篇文章詳細介紹了相對應(yīng)的分析和解答，希望可以幫助更多想解決這個問題的小伙伴找到更簡單易行的方法。

網(wǎng)站建設(shè)公司,為您提供網(wǎng)站建設(shè),網(wǎng)站制作,網(wǎng)頁設(shè)計及定制網(wǎng)站建設(shè)服務(wù),專注于企業(yè)網(wǎng)站制作,高端網(wǎng)頁制作,對PVC花箱等多個行業(yè)擁有豐富的網(wǎng)站建設(shè)經(jīng)驗的網(wǎng)站建設(shè)公司。專業(yè)網(wǎng)站設(shè)計,網(wǎng)站優(yōu)化推廣哪家好,專業(yè)seo優(yōu)化排名優(yōu)化,H5建站,響應(yīng)式網(wǎng)站。

@Bean和@Configuration

@Configuration注解的類，表示這個類是一個配置類，類似于<beans></beans>或者.xml文件。

@Bean注解用來說明使用springIoc容器管理一個新對象的實例化、配置和初始化。類似于<bean></bean>，默認情況下，bean名稱就是方法名稱.

例子：

@Configuration
public class Conf {
  
  @Bean
  public HelloService helloService() {
    return new HelloServiceImpl();
  }
  
}

這種配置方式就類似于xml配置中的

<beans>
  <bean id="helloService" class="com.dust.service.impl.HelloServiceImpl" />
</beans>

等價于注解配置中的

@Service
public class HelloServiceIMpl implements HelloService {
  
  @Override
  public String hello() {
    return "hello world";
  }
  
}

使用AnnotationConfigApplicationContext實例化Spring容器

這是在spring3.0加入的功能，除了接收@Configuration注解的類作為輸入類之外還可以接受使用JSR-330元數(shù)據(jù)注解的簡單類和@Component類。

當@Configuration注解的類作為輸入時，@Configuration類本身會被注冊為一個bean，在這個類中所有用@Bean注解的方法都會被定義為一個bean。

具體有哪些類型的bean可以方法遍歷打印容器中的bean。

  public static void main(String[] args) {
    ApplicationContext context = new AnnotationConfigApplicationContext(Conf.class);
    HelloService helloService = context.getBean(HelloService.class);
    String hello = helloService.hello();
    System.out.println(hello);
  }

該實例的步驟為：

1. 創(chuàng)建AnnotationConfigApplicationContext容器對象，同時將@Configuration注解的Conf.class作為參數(shù)傳入。
2. 容器回根據(jù)傳入的Conf類來構(gòu)建bean。其中就有helloService
3. 通過bean的對象類型獲取到容器中保管的對象。
4. 執(zhí)行對象方法

但是AnnotationConfigApplicationContext并不僅使用@Configuration類。任何@Component或JSR-330注解的類都可以作為輸入提供給構(gòu)造函數(shù)。例如：

  public static void main(String[] args) {
    ApplicationContext context = new AnnotationConfigApplicationContext(HelloServiceImpl.class, A.class, B.class);
    HelloService helloService = context.getBean(HelloService.class);
    String hello = helloService.hello();
    System.out.println(hello);
  }

上面假設(shè)MyServiceImpl、A和B都用了Spring的依賴注入的注解，例如@Autowired。

使用register(Class<?>…)的方式構(gòu)建容器

也可以使用無參構(gòu)造函數(shù)實例化AnnotationConfigApplicationContext，然后使用register()方法配置。當使用編程方式構(gòu)建AnnotationConfigApplicationContext時，這種方法特別有用。

例子：

  public static void main(String[] args) {
    AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
    context.register(Conf.class);
    context.refresh();
    HelloService helloService = context.getBean(HelloService.class);
    String hello = helloService.hello();
    System.out.println(hello);
  }

其中的refresh方法是一個初始化工作。否則注冊的類并不會被生成bean。

使用scan（String …）組件掃描

組件掃描，只需要設(shè)置好對應(yīng)包路徑，spring容器回自動掃描包下面所有能夠被容器初始化的Java類。

使用注解：

@Configuration
@ComponentScan("com.example.springdemo.beans")
public class Conf {

  @Bean
  public HelloService helloService() {
    //用這種方法創(chuàng)建的service相當于用@Service注解標注
    return new HelloServiceImpl();
  }

}

在該路徑下還有一個配置文件：

@Configuration
public class Conf2 {

  @Bean
  public ByeService byeService() {
    //用這種方法創(chuàng)建的service相當于用@Service注解標注
    return new ByeServiceImpl();
  }

}

然后是初始化容器：

  public static void main(String[] args) {
    AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
    context.register(Conf.class);
    context.refresh();
    ByeService byeService = context.getBean(ByeService.class);
    String hello = byeService.bye();
    System.out.println(hello);
  }

可以看到，雖然傳入的是Conf類，但是由于包掃描機制，該容器同時創(chuàng)建了Conf2類中的bean。

這就類似xml配置中的：

<beans>
  <context:component-scan base-package="com.example.springdemo.beans"/>
</beans>

還可以直接調(diào)用容器的掃描方法

  public static void main(String[] args) {
    AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
//    context.register(Conf.class);
    context.scan("com.example.springdemo.beans");
    context.refresh();
    ByeService byeService = context.getBean(ByeService.class);
    String hello = byeService.bye();
    System.out.println(hello);
  }

springboot中的包掃描

springboot通過main方法啟動，其中的注解為@SpringBootApplication。通過查看該注解的代碼可以發(fā)現(xiàn)一下代碼段：

@AliasFor(
  annotation = ComponentScan.class,
  attribute = "basePackages"
)

由此可以知道@SpringBootApplication注解包括了包掃描注解，同時掃描的是該類的目錄以及子目錄的所有可以被spring容器初始化的類

AnnotationConfigWebApplicationContext對于web應(yīng)用的支持

AnnotationConfigApplicationContext在WebApplicationContext中的變體為 AnnotationConfigWebApplicationContext。當配置Spring ContextLoaderListener servlet 監(jiān)聽器、Spring MVC DispatcherServlet的時候，可以用此實現(xiàn)。

Bean依賴

@Bean注解方法可以具有描述構(gòu)建該bean所需依賴關(guān)系的任意數(shù)量的參數(shù)。依賴的必須也是Ioc容器中注冊的bean。

將上面的代碼修改后如下：

@Configuration
public class Conf {

  @Bean
  public HelloService helloService(ByeService byeService) {
    return new HelloServiceImpl(byeService);
  }

  @Bean
  public ByeService byeService() {
    return new ByeServiceImpl();
  }

}
public class HelloServiceImpl implements HelloService {

  private ByeService byeService;

  public HelloServiceImpl(ByeService byeService) {
    this.byeService = byeService;
  }
  
  @Override
  public String hello() {
    return "hello world" + byeService.bye();
  }
  
}
  public static void main(String[] args) {
    AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
    context.register(Conf.class);
    context.refresh();
    HelloService helloService = context.getBean(HelloService.class);
    String hello = helloService.hello();
    System.out.println(hello);
    ByeService byeService = context.getBean(ByeService.class);
    String bye = byeService.bye();
    System.out.println(bye);
  }

輸出結(jié)果：

hello worldGoodbye!

Goodbye!

這種解決原理和基于構(gòu)造函數(shù)的依賴注入幾乎相同。

生命周期回調(diào)

@Bean注解支持任意的初始化和銷毀回調(diào)方法，這與Spring XML 中bean元素上的init方法和destroy-method屬性非常相似：

  @Bean(initMethod = "init")
  public HelloService helloService(ByeService byeService) {
    return new HelloServiceImpl(byeService);
  }

  @Bean(destroyMethod = "destroy")
  public ByeService byeService() {
    return new ByeServiceImpl();
  }

public interface ByeService {

  String bye();

  void destroy();

}

public interface HelloService {

  String hello();

  void init();
}

  public static void main(String[] args) {
    AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
    context.register(Conf.class);
    context.refresh();
    context.close();
  }

輸出如下：

init helloService!!

destroy byeService!

默認情況下，Ioc容器關(guān)閉后所有bean都會被銷毀，但是如果要引入一個生命周期在應(yīng)用程序之外進行管理的組件，例如：DataSource。那么只需要將@Bean（destroyMethod =””）添加到你的bean定義中即可禁用默認（推測）模式。

@Bean(destroyMethod="")
public DataSource dataSource() throws NamingException {
  return (DataSource) jndiTemplate.lookup("MyDS");
}

當然，初始化的時候也可以先執(zhí)行對應(yīng)方法，而不用交給Ioc容器

  @Bean
  public HelloService helloService(ByeService byeService) {
    HelloService helloService = new HelloServiceImpl(byeService);
    helloService.init();
    return helloService;
  }

@Scope和scope 代理

Scope描述的是Spring容器如何新建Bean實例的。

  1. Singleton：一個Spring容器中只有一個Bean的實例，此為Spring的默認配置，全容器共享一個實例。

  2. Prototype：每次調(diào)用新建一個Bean實例。

  3. Request：Web項目中，給每一個 http request 新建一個Bean實例。

  4. Session：Web項目中，給每一個 http session 新建一個Bean實例。

  5. GlobalSession：這個只在portal應(yīng)用中有用，給每一個 global http session 新建一個Bean實例。

  @Bean
  //每次調(diào)用就創(chuàng)建一個新的bean
  @Scope("prototype")
  public UserInfo userInfo() {
    return new UserInfo();
  }

  @Bean
  public UserService userService() {
    UserService userService = new UserServiceImpl();
    userService.init(userInfo());
    return userService;
  }

測試代碼：

  public static void main(String[] args) {
    AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
    context.register(Conf.class);
    context.refresh();
    UserService userService = context.getBean(UserService.class);
    UserService userService2 = context.getBean(UserService.class);
    UserInfo userInfo = context.getBean(UserInfo.class);
    UserInfo userInfo2 = context.getBean(UserInfo.class);
    System.out.println(userService == userService2);
    System.out.println(userInfo == userInfo2);
  }

輸出：

true

false

自定義Bean命名

通常，bean的名稱是bean的方法名，但是可以通過name屬性重命名。有時一個單一的bean需要給出多個名稱，稱為bean別名。為了實現(xiàn)這個目標，@Bean注解的name屬性接受一個String數(shù)組。

  @Bean(name = {"user", "userService", "User"})
  public UserService userService() {
    UserService userService = new UserServiceImpl();
    userService.init(userInfo());
    return userService;
  }
  public static void main(String[] args) {
    AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
    context.register(Conf.class);
    context.refresh();
    Object user = context.getBean("user");
    Object userService = context.getBean("userService");
    Object User = context.getBean("User");

    System.out.println(user == userService);
    System.out.println(user == User);
    System.out.println(userService == User);
  }

輸出：

true

true

true

Bean描述

有時候需要提供一個詳細的bean描述文本是非常有用的。當對bean暴露（可能通過JMX）進行監(jiān)控使，特別有用?？梢允褂聾Description注解對Bean添加描述：

  @Bean(name = {"user", "userService", "User"})
  @Description("這是用戶服務(wù)對象")
  public UserService userService() {
    UserService userService = new UserServiceImpl();
    userService.init(userInfo());
    return userService;
  }
  public static void main(String[] args) {
    AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
    context.register(Conf.class);
    context.refresh();
    String description = context.getBeanDefinition("user").getDescription();
    System.out.println(description);
  }

輸出：

這是用戶服務(wù)對象

基于Java組合配置

使用@Import注解

和Spring XML文件中使用元素來幫助模塊化配置類似，@Import注解允許從另一個配置類加載@Bean定義：

@Configuration
@Import(UserConf.class)
public class Conf {

  @Bean(initMethod = "init")
  public HelloService helloService(ByeService byeService) {
    //用這種方法創(chuàng)建的service相當于用@Service注解標注
    return new HelloServiceImpl(byeService);
  }

  @Bean(destroyMethod = "destroy")
  public ByeService byeService() {
    return new ByeServiceImpl();
  }

}
@Configuration
public class UserConf {

  @Bean
  //每次調(diào)用就創(chuàng)建一個新的bean
  @Scope("prototype")
  public UserInfo userInfo() {
    return new UserInfo();
  }

  @Bean(name = {"user", "userService", "User"})
  @Description("這是用戶服務(wù)對象")
  public UserService userService() {
    UserService userService = new UserServiceImpl();
    userService.init(userInfo());
    return userService;
  }

}
  public static void main(String[] args) {
    AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
    context.register(Conf.class);
    context.refresh();
    String description = context.getBeanDefinition("user").getDescription();
    System.out.println(description);
  }

這種方法簡化了容器實例化，因為只需要處理一個類，而不是需要開發(fā)人員在構(gòu)建期間記住大量的@Configuration注解類。

Java and XML 混合配置

Java配置并不能100%替代xml配置，因此Ioc容器支持兩者混合配置。不過這里有個區(qū)別就是以xml為中心還是以Java配置為中心。

以XML為中心

@Configuration
public class DataSourceConf {

  @Autowired
  private DataSource dataSource;

  @Bean
  public DataSourceService dataSource() {
    return new DataSourceerviceImpl(dataSource);
  }

}
jdbc.url=jdbc:MySQL://39.108.119.174:3306/dust
jdbc.username=root
jdbc.password=123456
<beans>

  <context:annotation-config/>

  <context:property-placeholder location="classpath:jdbc.properties"/>

  <bean class="com.example.springdemo.beans.DataSourceConf"/>

  <bean class="org.springframework.jdbc.datasource.DriverManagerDataSource">
    <property name="url" value="${jdbc.url}"/>
    <property name="username" value="${jdbc.username}"/>
    <property name="password" value="${jdbc.password}"/>
  </bean>

</beans>
  public static void main(String[] args) {
    ApplicationContext context = new ClassPathXmlApplicationContext("classpath:spring/datasource.xml");
    DataSourceService dataSourceService = context.getBean(DataSourceService.class);
    System.out.println(dataSourceService.toString());
  }

以Java類為中心

<beans>
  <context:property-placeholder location="classpath:jdbc.properties"/>
</beans>
@Configuration
@ImportResource("classpath:spring/datasource.xml")
public class DataSourceConf {

  @Value("${jdbc.url}")
  private String url;

  @Value("${jdbc.username}")
  private String username;

  @Value("${jdbc.password}")
  private String password;

  @Bean
  public DataSourceService dataSource() {
    return new DataSourceerviceImpl(url, username, password);
  }

}
  public static void main(String[] args) {
    AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
    context.scan("com.example.springdemo.beans");
    context.refresh();
    DataSourceService dataSourceService = context.getBean(DataSourceService.class);
    System.out.println(dataSourceService.toString());

//    ApplicationContext context = new ClassPathXmlApplicationContext("classpath:spring/datasource.xml");
//    DataSourceService dataSourceService = context.getBean(DataSourceService.class);
//    System.out.println(dataSourceService.toString());
  }

springboot是什么

springboot一種全新的編程規(guī)范，其設(shè)計目的是用來簡化新Spring應(yīng)用的初始搭建以及開發(fā)過程，SpringBoot也是一個服務(wù)于框架的框架，服務(wù)范圍是簡化配置文件。

關(guān)于如何在Java容器中配置spring boot問題的解答就分享到這里了，希望以上內(nèi)容可以對大家有一定的幫助，如果你還有很多疑惑沒有解開，可以關(guān)注創(chuàng)新互聯(lián)行業(yè)資訊頻道了解更多相關(guān)知識。

文章名稱：如何在Java容器中配置springboot
文章轉(zhuǎn)載：http://muchs.cn/article18/piosdp.html

成都網(wǎng)站建設(shè)公司_創(chuàng)新互聯(lián)，為您提供軟件開發(fā)、App開發(fā)、品牌網(wǎng)站設(shè)計、營銷型網(wǎng)站建設(shè)、企業(yè)建站、微信公眾號

廣告

聲明：本網(wǎng)站發(fā)布的內(nèi)容（圖片、視頻和文字）以用戶投稿、用戶轉(zhuǎn)載內(nèi)容為主，如果涉及侵權(quán)請盡快告知，我們將會在第一時間刪除。文章觀點不代表本網(wǎng)站立場，如需處理請聯(lián)系客服。電話：028-86922220；郵箱：631063699@qq.com。內(nèi)容未經(jīng)允許不得轉(zhuǎn)載，或轉(zhuǎn)載時需注明來源： 創(chuàng)新互聯(lián)

h5響應(yīng)式網(wǎng)站建設(shè)