程序员最近都爱上了这个网站  程序员们快来瞅瞅吧!  it98k网:it98k.com

本站消息

站长简介/公众号

  出租广告位,需要合作请联系站长


+关注
已关注

分类  

暂无分类

标签  

暂无标签

日期归档  

暂无数据

【SpringBoot】| Spring Boot 概述和入门程序剖析

发布于2023-06-04 19:47     阅读(787)     评论(0)     点赞(25)     收藏(3)


目录

一:Spring Boot 入门

1. SpringBoot特点

2. 创建Spring Boot项目

3. SpringBoot核心配置文件

4. SpringBoot中使用JSP(了解)

5. SpringBoot中使用ApplicationContext

6. CommandLineRunner接口 & ApplicationRunner接口

图书推荐:集齐“Java四大名著”召唤神龙


一:Spring Boot 入门

SpringBoot是Spring家族中的一个成员, 可以简化Spring、SpringMVC的使用。它的核心还是IOC容器!

1. SpringBoot特点

特点如下:

①Create stand-alone Spring applications.

解释:创建一个独立spring应用(用SpringBoot实际上还是用spring)。

②Embed Tomcat, Jetty or Undertow directly (no need to deploy WAR files).

解释:内嵌Tomcat、Jetty或Undertow服务器(无需部署WAR文件)。

③Provide opinionated 'starter' dependencies to simplify your build configuration.

解释:提供了starter起步依赖,简化应用的配置。比如:使用MyBatis框架 , 需要在Spring项目中,配置MyBatis的对象 SqlSessionFactory , Dao的代理对象等;现在在SpringBoot项目中,在pom.xml里面, 只需要加入一个 mybatis-spring-boot-starter依赖,就表示上面两个等配置已经配置好了。

④Automatically configure Spring and 3rd party libraries whenever possible.

解释:尽可能自动配置Spring和第三方库。(就是把spring中的,第三方库中的对象都提前创建好,放到容器中, 可以直接使用)。

⑤Provide production-ready features such as metrics, health checks, and externalized configuration

解释:提供生产就绪功能,如指标、运行状况检查和外部化配置。

⑥Absolutely no code generation and no requirement for XML configuration

解释:不用生成代码, 不用使用xml做配置。

2. 创建Spring Boot项目

第一种方式:https://start.spring.io,使用国外的地址,必须联网

①新建项目

 ②设置基本信息

③选择依赖的列表

④项目的结构

⑤生成的pom.xml配置

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  3. xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
  4. <modelVersion>4.0.0</modelVersion>
  5. <!--SpringBoot项目的父项目-->
  6. <parent>
  7. <groupId>org.springframework.boot</groupId>
  8. <artifactId>spring-boot-starter-parent</artifactId>
  9. <version>3.0.3</version>
  10. <relativePath/>
  11. </parent>
  12. <!--当前项目的gav坐标-->
  13. <groupId>com.zl</groupId>
  14. <artifactId>study-springboot-002</artifactId>
  15. <version>0.0.1-SNAPSHOT</version>
  16. <name>study-springboot-002</name>
  17. <description>study-springboot-002</description>
  18. <!--JDK的版本-->
  19. <properties>
  20. <java.version>1.8</java.version>
  21. </properties>
  22. <dependencies>
  23. <!--web依赖,版本号就是父的版本号-->
  24. <dependency>
  25. <groupId>org.springframework.boot</groupId>
  26. <artifactId>spring-boot-starter-web</artifactId>
  27. </dependency>
  28. <!--测试-->
  29. <dependency>
  30. <groupId>org.springframework.boot</groupId>
  31. <artifactId>spring-boot-starter-test</artifactId>
  32. <scope>test</scope>
  33. </dependency>
  34. </dependencies>
  35. <build>
  36. <plugins>
  37. <!--maven的插件-->
  38. <plugin>
  39. <groupId>org.springframework.boot</groupId>
  40. <artifactId>spring-boot-maven-plugin</artifactId>
  41. </plugin>
  42. </plugins>
  43. </build>
  44. </project>

第二种方式:https://start.springboot.io,使用国外的地址,必须联网,创建项目的步骤同上

①对于其他版本的高版本的IDEA是以下界面

②也可以在浏览器上直接输入https://start.springboot.io 进行设置

③选择好以后,点击生成GENERATE,会下载一个压缩包

④解压这个压缩包,就可以把项目导进去

第三种方式:使用 maven 向导创建项目

①创建一个普通的Maven项目

②手动添加父gav和web的依赖

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <project xmlns="http://maven.apache.org/POM/4.0.0"
  3. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4. xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  5. <modelVersion>4.0.0</modelVersion>
  6. <groupId>com.zl</groupId>
  7. <artifactId>study-springboot-004</artifactId>
  8. <version>1.0.0</version>
  9. <packaging>jar</packaging>
  10. <!--手动添加SpringBoot项目的父项目-->
  11. <parent>
  12. <groupId>org.springframework.boot</groupId>
  13. <artifactId>spring-boot-starter-parent</artifactId>
  14. <version>3.0.3</version>
  15. <relativePath/>
  16. </parent>
  17. <!--手动添加依赖-->
  18. <dependencies>
  19. <dependency>
  20. <groupId>org.springframework.boot</groupId>
  21. <artifactId>spring-boot-starter-web</artifactId>
  22. </dependency>
  23. </dependencies>
  24. <properties>
  25. <maven.compiler.source>8</maven.compiler.source>
  26. <maven.compiler.target>8</maven.compiler.target>
  27. </properties>
  28. </project>

③手动添加项目缺失的目录

入门案例:

第一步:创建一个SpringBoot的web工程项目

第二步:创建一个Controller,发出请求

注:在使用springmvc框架的时候,在处理json的时候需要用到spring框架特有的注解@ResponseBody或者@RestController注解,这两个注解都会处理返回的数据格式,使用了该类型注解后返回的不再是视图,不会进行转跳,而是返回json或xml数据格式,输出在页面上。

①@ResponseBody,一般是使用在单独的方法上的,需要哪个方法返回json数据格式,就在哪个方法上使用,具有针对性。

②@RestController,一般是使用在类上的,它表示的意思其实就是结合了@Controller和@ResponseBody两个注解,如果哪个类下的所有方法需要返回json数据格式的,就在哪个类上使用该注解,具有统一性;需要注意的是,使用了@RestController注解之后,其本质相当于在该类的所有方法上都统一使用了@ResponseBody注解,所以该类下的所有方法都会返回json数据格式,输出在页面上,而不会再返回视图。

  1. package com.zl.controller;
  2. import org.springframework.stereotype.Controller;
  3. import org.springframework.web.bind.annotation.RequestMapping;
  4. import org.springframework.web.bind.annotation.ResponseBody;
  5. @Controller // 类要想当做controller使用,就添加这个注解
  6. public class HelloSpringBoot {
  7. @RequestMapping("/hello")
  8. @ResponseBody // 把返回的String字符串当做数据来用,返回给浏览器
  9. public String helloSpringBoot(){
  10. return "欢迎使用SpringBoot!";
  11. }
  12. }

第三步:启动入口类,这个类是自动生成的

注:这个类的执行会启动内置的Tomcat服务器!

  1. package com.zl;
  2. import org.springframework.boot.SpringApplication;
  3. import org.springframework.boot.autoconfigure.SpringBootApplication;
  4. @SpringBootApplication
  5. public class Application {
  6. public static void main(String[] args) {
  7. SpringApplication.run(Application.class, args);
  8. }
  9. }

第四步:进行访问

SpringBoot中几个重要的注解

①@SpringBootApplication注解: @SpringBootApplication注解其实是一个复合注解,是由 @SpringBootConfiguration注解@EnableAutoConfiguration注解@ComponentScan 联合在一起组成的;从源码中就可以看出:

②@SpringBootConfiguration注解: 这个注解就是@Configuration这个注解的功能,使用@SpringBootConfiguration这个注解的类就是当做配置文件作用,从源码中就可以看出:

注:既然有@Configuration功能,结合@Bean注解,就可以把一个对象放到Spring容器当中 

  1. package com.zl;
  2. import com.zl.controller.Student;
  3. import org.springframework.boot.SpringApplication;
  4. import org.springframework.boot.autoconfigure.SpringBootApplication;
  5. import org.springframework.context.annotation.Bean;
  6. @SpringBootApplication
  7. public class Application {
  8. public static void main(String[] args) {
  9. SpringApplication.run(Application.class, args);
  10. }
  11. // 声明对象,把这个对象注入到Spring容器当中
  12. @Bean
  13. public Student myStudent(){
  14. return new Student();
  15. }
  16. }

③@EnableAutoConfiguration注解:启用自动配置, 把java对象配置好,注入到spring容器中。例如:可以把mybatis的对象创建好,放入到容器中

④@ComponentScan注解:组件扫描器, 扫描注解,根据注解的功能,创建java bean,给属性赋值等。组件扫描器默认扫描的包是 @ComponentScan 注解所在的类, 类所在的包和子包。 所以对于带有@SpringBootApplication注解的入口类Application建议放在主包下!

3. SpringBoot核心配置文件

配置文件名称是:application扩展名有:properties、yml;例如:application.properties或者application.yml。

注:使用properties扩展名配置是key=value的格式,使用yml扩展名配置是key:value的格式

第一步:创建一个controller

  1. package com.zl.controller;
  2. import org.springframework.stereotype.Controller;
  3. import org.springframework.web.bind.annotation.RequestMapping;
  4. import org.springframework.web.bind.annotation.ResponseBody;
  5. @Controller
  6. public class SpringController {
  7. @RequestMapping("/spring")
  8. @ResponseBody
  9. public String doSome(){
  10. return "hello SpringBoot";
  11. }
  12. }

第二步:创建启动类,对于启动类我们可以删除自动生成的,自己手写一个

①类名随意,里面有一个主方法,在主方法中调用SpringApplication的run方法,一个参数是本类.class,另一个参数是上面main方法的参数args

②给本类增加上@SpringBootApplication注解。

  1. package com.zl;
  2. import org.springframework.boot.SpringApplication;
  3. import org.springframework.boot.autoconfigure.SpringBootApplication;
  4. @SpringBootApplication
  5. public class MyApplication {
  6. public static void main(String[] args) {
  7. SpringApplication.run(MyApplication.class,args);
  8. }
  9. }

第三步:使用application.properties/yml配置文件,配置端口号、上下文的路径等

①采用默认的

②自己进行配置application.properties,#代表注释

  1. #设置端口号
  2. server.port=8082
  3. #设置访问应用上下文路径,contextpath
  4. server.servlet.context-path=/myboot

 ③使用yml的配置方式,application.yml

yml是一种yaml格式的配置文件,主要采用一定的空格、换行等格式排版进行配置。 yaml是一种直观的能够被计算机识别的的数据序列化格式,容易被人类阅读,yaml 类似于xml,但是语法比xml 简洁很多,值与前面的冒号配置项必须要有一个空格, yml 缀也可以使用 yaml 后缀。

  1. server:
  2. port: 8082
  3. servlet:
  4. context-path: /myboot

注意: 当两种格式配置文件同时存在,默认使用的是properties,在SpringBoot2.4开始,使用的是yml配置文件,推荐使用 yml格式配置文件

【多环境测试】

在实际开发的过程中,我们的项目会经历很多的阶段(开发->测试->上线),每个阶段的配置也会不同,例如:端口、上下文根、数据库等,那么这个时候为了方便在不同的环境之间切换,SpringBoot 提供了多环境配置,具体步骤如下:

注:为每个环境创建一个配置文件,命名必须以application-环境标识.propertiesyml! 

开发环境application-dev.properties:

  1. #配置端口号
  2. server.port=8081
  3. #配置应用根路径
  4. server.servlet.context-path=/mydev

测试环境application-test.properties:

  1. #配置端口号
  2. server.port=8082
  3. #配置应用根路径
  4. server.servlet.context-path=/mytest

上线环境application-onlion.properties:

  1. #配置端口号
  2. server.port=8083
  3. #配置应用根路径
  4. server.servlet.context-path=/myonlion

在application.properties中指定要使用的配置文件

  1. #激活使用哪个配置文件
  2. spring.profiles.active=dev
  3. spring.profiles.active=test
  4. spring.profiles.active=onlion

【自定义配置】

(1)@Value注解

注:在application.properties中添加自定义的配置项,然后在类中需要时,使用@Value(${变量名})注解进行引入。

application.properties配置

  1. #配置端口号
  2. server.port=8082
  3. #context-path
  4. server.servlet.context-path=/myboot
  5. #自定义key=value
  6. school.name=大连大学
  7. school.website=www.baidu.com
  8. school.address=辽宁省大连市
  9. site=www.sina.com.cn

在controller中联合@Value注解获取数据

  1. package com.zl.controller;
  2. import org.springframework.beans.factory.annotation.Value;
  3. import org.springframework.stereotype.Controller;
  4. import org.springframework.web.bind.annotation.RequestMapping;
  5. import org.springframework.web.bind.annotation.ResponseBody;
  6. @Controller
  7. public class DataController {
  8. // 定义变量接收赋值
  9. @Value("${server.port}")
  10. private Integer port;
  11. @Value("${server.servlet.context-path}")
  12. private String contextPath;
  13. // 自定义的
  14. @Value("${school.name}")
  15. private String name;
  16. @Value("${site}")
  17. private String site;
  18. @RequestMapping("/data")
  19. @ResponseBody
  20. public String queryData(){
  21. return name+","+site+",项目访问的地址"+contextPath+",使用的端口"+port;
  22. }
  23. }

执行结果:

(2)@ConfigurationProperties注解

前面我们是一个个取出值,现在我们将整个文件映射成一个Java对象,用于自定义配置项比较多的情况! 

工作原理:定义一个类使用@ConfigurationProperties注解,并指定前缀prefix,它会根据这个前缀到配置中找以这个前缀开头的属性;如果以这个前缀开头的后面的属性与我们定义的Java对象的属性相同就赋上值!

定义一个School类

关键点:配置文件的数据与School类中的属性怎么对应上?

使用@ConfigurationProperties注解,指定一个前缀!

  1. package com.zl.vo;
  2. import org.springframework.boot.context.properties.ConfigurationProperties;
  3. import org.springframework.stereotype.Component;
  4. @Component // 创建对象
  5. @ConfigurationProperties(prefix = "school") // 把school开头的配置项找出来
  6. public class School {
  7. private String name;
  8. private String website;
  9. private String address;
  10. public School() {
  11. }
  12. public School(String name, String website, String address) {
  13. this.name = name;
  14. this.website = website;
  15. this.address = address;
  16. }
  17. @Override
  18. public String toString() {
  19. return "School{" +
  20. "name='" + name + '\'' +
  21. ", website='" + website + '\'' +
  22. ", address='" + address + '\'' +
  23. '}';
  24. }
  25. public String getName() {
  26. return name;
  27. }
  28. public void setName(String name) {
  29. this.name = name;
  30. }
  31. public String getWebsite() {
  32. return website;
  33. }
  34. public void setWebsite(String website) {
  35. this.website = website;
  36. }
  37. public String getAddress() {
  38. return address;
  39. }
  40. public void setAddress(String address) {
  41. this.address = address;
  42. }
  43. }

进行测试:

  1. package com.zl.controller;
  2. import com.zl.vo.School;
  3. import org.springframework.stereotype.Controller;
  4. import org.springframework.web.bind.annotation.RequestMapping;
  5. import org.springframework.web.bind.annotation.ResponseBody;
  6. import javax.annotation.Resource;
  7. @Controller
  8. public class DataController {
  9. @Resource // 赋值
  10. private School school;
  11. @RequestMapping("/school")
  12. @ResponseBody
  13. public School querySchool(){
  14. return school;
  15. }
  16. }

执行结果:

实际上还有一个报错信息,让我们添加一个依赖,当然不添加也不影响的项目的正常运行

 添加以下依赖

  1. <!--处理ConfigurationProperties注解有关的元数据-->
  2. <dependency>
  3. <groupId>org.springframework.boot</groupId>
  4. <artifactId>spring-boot-configuration-processor</artifactId>
  5. <optional>true</optional>
  6. </dependency>

4. SpringBoot中使用JSP(了解)

SpringBoot不推荐使用jsp ,而是使用模板技术代替jsp,作为视图来使用!

使用jsp需要配置:

①加入一个处理jsp的依赖, 负责编译jsp文件

  1. <dependency>
  2. <groupId>org.apache.tomcat.embed</groupId>
  3. <artifactId>tomcat-embed-jasper</artifactId>
  4. </dependency>

②如果需要使用servlet, jsp,jstl的功能,还需要加对应的依赖

  1. <dependency>
  2. <groupId>javax.servlet</groupId>
  3. <artifactId>jstl</artifactId>
  4. </dependency>
  5. <dependency>
  6. <groupId>javax.servlet</groupId>
  7. <artifactId>javax.servlet-api</artifactId>
  8. </dependency>
  9. <dependency>
  10. <groupId>javax.servlet.jsp</groupId>
  11. <artifactId>javax.servlet.jsp-api</artifactId>
  12. <version>2.3.1</version>
  13. </dependency>

③创建一个存放jsp的目录,一般叫做webapp,这个目录默认是不能创建jsp文件,需要我们手动更改webapp目录的属性

编写index.jsp页面

  1. <%@ page contentType="text/html;charset=UTF-8" language="java" %>
  2. <html>
  3. <head>
  4. <title>index.jsp</title>
  5. </head>
  6. <body>
  7. <h1>使用jsp显示Controller中的数据${data}</h1>
  8. </body>
  9. </html>

④需要在pom.xml指定jsp文件编译后的存放目录;META-INF/resources(固定的)

  1. <build>
  2. <!--指定jsp编译后的存放目录-->
  3. <resources>
  4. <resource>
  5. <!--jsp原来的目录-->
  6. <directory>src/main/webapp</directory>
  7. <!--指定编译后的存放目录-->
  8. <targetPath>META-INF/resources</targetPath>
  9. <!--指定处理的目录和文件-->
  10. <includes>
  11. <!--表示webapp下任意目录的任意文件-->
  12. <include>**/*.*</include>
  13. </includes>
  14. </resource>
  15. </resources>
  16. <plugins>
  17. <plugin>
  18. <groupId>org.springframework.boot</groupId>
  19. <artifactId>spring-boot-maven-plugin</artifactId>
  20. </plugin>
  21. </plugins>
  22. </build>

⑤创建Controller, 访问jsp

  1. package com.zl.controller;
  2. import org.springframework.stereotype.Controller;
  3. import org.springframework.ui.Model;
  4. import org.springframework.web.bind.annotation.RequestMapping;
  5. import javax.servlet.http.HttpServletRequest;
  6. @Controller
  7. public class JspController {
  8. // 方法一:使用HttpServletRequest对象
  9. /*public String doJsp(HttpServletRequest request){
  10. request.setAttribute("data","SpringBoot使用JSP进行显示");
  11. // 返回视图的逻辑名称
  12. return "index";
  13. }*/
  14. // 方法二:使用Model对象
  15. @RequestMapping("/myjsp")
  16. public String doJsp(Model model){
  17. model.addAttribute("data","SpringBoot使用JSP进行显示");
  18. // 返回视图的逻辑名称
  19. return "index";
  20. }
  21. }

⑥在application.propertis文件中配置视图解析器

  1. #配置端口号
  2. server.port=9090
  3. #配置context-path
  4. server.servlet.context-path=/myboot
  5. #配置视图解析器
  6. # / 就是src/main/webapp
  7. spring.mvc.view.prefix=/
  8. spring.mvc.view.suffix=.jsp

5. SpringBoot中使用ApplicationContext

怎么使用容器对象?要想从容器中获取对象,通过SpringApplication.run(Application.class, args); 返回值获取容器,返回值类型是什么呢?通过源码分析:

先定位到SpringApplication的run方法

run方法的返回值是ConfigurableApplicationContext接口

ConfigurableApplicationContext接口继承ApplicationContext接口

 所以run方法返回值其实就是一个ApplicationContext容器(Spring容器中创建ClassPathXmlApplicationContext对象时,返回的结果就是ApplicationContext[是ClassPathXmlApplicationContext的父类],然后调用getBean方法就能获取对象

案例:在main方法中使用SpringApplication.run()方法获取返回的Spring容器对象,再获取业务 bean进行调用!

创建一个UserService 接口:

  1. package com.zl.service;
  2. public interface UserService {
  3. void sayHello(String name);
  4. }

编写UserService接口的实现类:

  1. package com.zl.service.impl;
  2. import com.zl.service.UserService;
  3. import org.springframework.stereotype.Service;
  4. @Service("userService") // 交给Spring容器管理
  5. public class UserServiceImpl implements UserService {
  6. @Override
  7. public void sayHello(String name) {
  8. System.out.println("对"+name+"说sayHello");
  9. }
  10. }

在入口方法中取出被Spring容器管理的UserServiceImpl 类:

  1. package com.zl;
  2. import com.zl.service.UserService;
  3. import org.springframework.boot.SpringApplication;
  4. import org.springframework.boot.autoconfigure.SpringBootApplication;
  5. import org.springframework.context.ApplicationContext;
  6. import org.springframework.context.ConfigurableApplicationContext;
  7. @SpringBootApplication
  8. public class Application {
  9. public static void main(String[] args) {
  10. // 返回一个ConfigurableApplicationContext接口容器或者父接口的
  11. // ConfigurableApplicationContext cac = SpringApplication.run(Application.class, args);
  12. ApplicationContext cac = SpringApplication.run(Application.class, args);
  13. // 调用getBean方法,获取交给Spring容器管理的对象
  14. UserService userService = cac.getBean("userService", UserService.class);
  15. // 方法的调用
  16. userService.sayHello("张三");
  17. }
  18. }

执行结果:

6. CommandLineRunner接口 & ApplicationRunner接口

(1)开发中可能会有这样的情景:需要在容器启动后执行一些内容;比如:读取配置文件,数据库连接之类的;SpringBoot 给我们提供了两个接口来帮助我们实现这种需求,这两个接口分别为CommandLineRunner ApplicationRunner,它们的执行时机为容器启动完成的时候(容器对象创建好后,自动执行run方法)

(2)两个接口中有一个run()方法,我们只需要实现这个方法即可

(3)这两个接口的不同之处在于:ApplicationRunner中run()方法的参数为ApplicationArguments,而CommandLineRunner接口中run方法的参数为String 数组

ApplicationRunner接口

  1. package org.springframework.boot;
  2. @FunctionalInterface
  3. public interface ApplicationRunner {
  4. void run(ApplicationArguments args) throws Exception;
  5. }

CommandLineRunner接口

  1. package org.springframework.boot;
  2. @FunctionalInterface
  3. public interface CommandLineRunner {
  4. void run(String... args) throws Exception;
  5. }

案例:

编写SomeService接口

  1. package com.zl.service;
  2. public interface SomeService {
  3. String doSome(String name);
  4. }

编写SomeService接口的实现类SomeServiceImpl 

  1. package com.zl.service.impl;
  2. import com.zl.service.SomeService;
  3. import org.springframework.stereotype.Service;
  4. @Service("someService") // 交给Spring容器管理
  5. public class SomeServiceImpl implements SomeService {
  6. @Override
  7. public String doSome(String name) {
  8. return name+"----》去打篮球了!";
  9. }
  10. }

让启动口类Application实现CommandLineRunner接口,并重写run()方法

  1. package com.zl;
  2. import com.zl.service.SomeService;
  3. import org.springframework.boot.CommandLineRunner;
  4. import org.springframework.boot.SpringApplication;
  5. import org.springframework.boot.autoconfigure.SpringBootApplication;
  6. import org.springframework.stereotype.Service;
  7. import javax.annotation.Resource;
  8. @SpringBootApplication
  9. public class Application implements CommandLineRunner {
  10. @Resource // 下面容器创建好以后就会给属性赋值
  11. private SomeService someService;
  12. public static void main(String[] args) {
  13. System.out.println("准备创建容器对象"); // 1
  14. // 创建容器对象
  15. SpringApplication.run(Application.class, args);
  16. System.out.println("容器对象创建好之后"); // 3
  17. }
  18. @Override
  19. public void run(String... args) throws Exception {
  20. // 在这个run方法里做自定义的操作
  21. System.out.println("容器对象创建好,马上执行的!"); // 2
  22. // 调用容器中对象的方法
  23. // 在这里执行,已经保证1的容器对象创建好了
  24. String str = someService.doSome("张大傻");
  25. System.out.println(str);
  26. }
  27. }

执行顺序结果:

图书推荐:集齐“Java四大名著”召唤神龙

Java 28岁了,当打之年,并且还会打很多年。为即将或正在使用Java的你推荐Java“此生错过必遗憾”系列书单。看看你还缺哪本?请补齐。优惠购书链接就在文中,拿好不谢!

1. Java核心技术第12版开发基础+高级特性

Java四大名著”之一Core Java最新版,一键打包全套2册!建议入门小白和准备升级到Java17的开发者购买。本书根据Java17新特性全面升级!赠送作者亲授视频课+海量代码集。

限时秒杀链接:点击购买

2. Java核心技术第11版基础知识+高级特性

Java四大名著”之一Core Java次新版,一键打包全套2册!建议实际生产环境仍在使用Java8Java11开发且暂时没有升级版本打算的开发者购买。本书基于Java9-11编写,赠送作者亲授视频课+海量代码集。

限时秒杀链接:点击购买

3. Java编程思想[Thinking in Java]

Java四大名著”之一需要有一定编程基础的人才可阅读,即使很多内容还无法理解,但每次读完一定会有所收获。本书单最前面推荐的《Java核心技术》侧重技术,而《Java编程思想》侧重于“思想”,本书为你剖析Java中各个内容的设计理念。这是一本伴随我们技术成长的好书,买一本放在旁边,摸着就有底气。

限时秒杀链接:点击购买

4. Effective Java 中文版(原书第3版)

 Java四大名著”之一适合已经掌握Java核心技术的程序员,想更加深入地了解Java编程语言的开发者阅读。针对如何编写高效、设计优良的程序提出了最实用、最权威的指导方针,通过90条简短、独立的经验法则,探索新的设计模式和语言习惯用法,帮你更加有效地使用Java编程语言及其基本类库,指引你少走弯路。这些经验规则涵盖了大多数开发人员每天所面临的问题的解决方案。是Java开发人员案头上的一本不可或缺的参考书。

限时秒杀链接:点击购买

5. Java语言程序设计基础篇+进阶篇

本套书相较于《Java核心技术》更加的基础,如果你阅读《Java核心技术》有些吃力,建议从本书读起。畅销20余年的“长城书”一键打包全套!被世界各地的大学选作教材,更新至Java9、10和11。本书通过示例讲解问题求解技巧,提供大量的程序清单,每章配有丰富的复习题和编程练习题,帮助读者掌握编程技术并解决实际开发中遇到的问题。

限时秒杀链接:点击购买

6. Java并发编程实战

让注重实战的你更快领悟Java并发编程的要领,快速构建大规模并发应用程序。Java四大名著”之一《Effective Java》的作者Joshua Bloch参与编写。本书是Java并发编程领域的里程碑著作!从并发编程的基本理论入手,逐步介绍了在设计Java并发程序时各种重要的设计原则、设计模式与思维模式。另一本蚂蚁金服方腾飞老师写的《Java并发编程的艺术》也适合一并阅读。

限时秒杀链接:点击购买

7. 软件架构实践

让你少走弯路的进阶架构师避坑指南!图书届奥斯卡Jolt大奖双冠王作品!全球10余个国出版。卡内基梅隆等名校教材,IEEE杂志10佳图书,软件架构图书事实标准。

 

限时秒杀链接:点击购买

以上图书当当网全部限时秒杀,满100-50,买的越多,优惠越多!了解更多好书点击:Core Java 全面升级!

原文链接:https://blog.csdn.net/m0_61933976/article/details/129307706



所属网站分类: 技术文章 > 博客

作者:java之恋

链接:http://www.javaheidong.com/blog/article/674108/55796fe135ac944d1a66/

来源:java黑洞网

任何形式的转载都请注明出处,如有侵权 一经发现 必将追究其法律责任

25 0
收藏该文
已收藏

评论内容:(最多支持255个字符)