Java 校招面经合集

2024-06-23 12:48
文章标签 java 校招 面经 合集

本文主要是介绍Java 校招面经合集，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

小博Java面试路上的点点滴滴

篇章小博博客地址
Java 面试之基础篇点击前往
Java 面试之框架篇点击前往
Java 面试之数据结构篇点击前往
Java 面试之JVM篇点击前往
Java 面试之多线程篇点击前往
Java 面试之数据库篇点击前往
Java 面试之计算机网络篇点击前往
Java 面试之操作系统篇点击前往
Java 面试之算法篇点击前往
Java 面试之附加篇点击前往

小博Spring Boot 入门教程

  相信小伙伴们在使用 Spring 或 SpringMVC 的过程中，或多或少会被各种配置问题所牵绊，这些配置不仅徒增工作量，而且在跨平台部署时容易出现问题。因此，Spring Boot 应运而生，它集成了大量常用的第三方库配置（例如 Jackson、JDBC、MongoDB、Redis、Mail 等等），这些第三方库几乎都可以零配置的开箱即用，可以帮助我们快速搭建一个项目，从而让开发者能够更加专注于业务逻辑。
  Spring Boot 的优点及特性，就不再逐一罗列了，针对 Spring Boot 的初学者，让我们先快速学会怎么用。

版本列表

名称版本备注
JDK1.8.0
MySQL5.7.15
IDEA Ultimate2017.2不能用社区版
Maven3.5.2可用阿里仓库提速
Spring Boot1.5.9

快速构建项目

  关于 Spring Boot 项目的构建，IDEA 为我们提供了良好的支持，在 IDEA 中 New→Project→Spring Initializr→Next→Next（可自己填写相关信息）→选中 Web 栏目的 Web 依赖→Next→Finish（可自己填写相关信息），一个简单 Spring Boot 项目搭建好了。没错不用惊讶，搭好了。接下来我们看看 IDEA 自动生成目录结构（以读者填写的具体信息为准）。

  • main
    • java
      • xin.chung.springboot
        • SpringbootApplication.java（项目入口文件）
    • resources
      • static（静态资源包）
      • templates（页面模板包）
      • application.properties（项目属性配置文件）
  • test
    • java
      • xin.chung.springboot
        • SpringbootApplicationTests.java（测试文件）

  IDEA 自动为我们生成了几个文件，其中 application.properties 文件为项目属性配置文件，一般包含服务器、数据库、日志等方面的配置，以及一些自定义的属性。SpringbootApplicationTests.java 是 JUnit 测试类，用来进行开发过程中的单元测试。这两类文件，留待后面详细介绍。而至于这个 SpringbootApplication.java 文件，它其实是项目的入口文件，内容也非常简单，如下：

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

  当我们运行这个类或主方法时，框架就会自动为我们开启服务。若见日志打印如下，说明启动成功，从日志可以看到，我们的 Tomcat 8080 端口已经准备就绪。

  .   ____          _            __ _ _/\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \\\/  ___)| |_)| | | | | || (_| |  ) ) ) )'  |____| .__|_| |_|_| |_\__, | / / / /=========|_|==============|___/=/_/_/_/:: Spring Boot ::        (v1.5.9.RELEASE)······Tomcat started on port(s): 8080 (http)
Started SpringbootApplication in 4.694 seconds (JVM running for 7.789)

关于项目构建途径或项目启动的其他方式，大家可在读者圈一起交流。

项目属性配置

单元测试

  在后续话题开始之前，我们有必要先探讨下单元测试。以往我们写一段测试代码，有一个前置步骤：用ClassPathXmlApplicationContext装载上下文，然后用ApplicationContext对象获取 Bean 实例。接下来，才能进行我们的测试代码编写。
  而在 Spring Boot 中，极大简化了测试代码，它为我们提供了@RunWith注解和@SpringBootTest注解分别用来指定测试运行类和运行 Spring Boot 基础测试环境。此时，你可以直接使用@Resource或@Autowired注入所需 Bean 并使用，示例如下：

@RunWith(SpringRunner.class)
@SpringBootTest
public class PropertiesTests {@Resourceprivate DemoService demoService;//仅作展示，还未编写@Testpublic void test() {System.out.println(demoService.getDemo().toString());}
}

由于单元测试贯穿本文，所以每个章节都会在相应的地方讨论 Spring Boot 中 JUnit 的具体使用方法，此处只写出最简单的使用示例。

属性配置

  在前面提到过的 application.properties 文件中，我们可以进行一些项目的配置，也可以自定义一些项目所需要的属性参数然后用@Value注解在Java文件中引用，例如：

# Server 服务相关
server.port=8080
server.context-path=/demo
# Log 日志相关
logging.path=/var/logs
logging.file=demo.log
# Other 自定义
author=chung
addr=http://example.cn/activity/5a444c451f6ee91a25846ac1

  我们可以编写如下测试代码，验证.properties文件中的值是否能被我们在 Java 文件中所使用，至于打印结果我就不贴出来了。

@RunWith(SpringRunner.class)
@SpringBootTest
public class PropertiesTests {@Value("${author}")private String author;@Value("${addr}")private String addr;@Testpublic void test() {System.out.println("author:" + author + "--addr:" + addr);}
}

  实际上，我们也可以使用 YAML 作为项目的配置文件，这种语言更加简洁明了。以上.properties文件，可等价如下.yml文件（切记:后面的空格不能少，同时注意每行的缩进）：

# Server 服务相关
server:port: 8080context-path: /demo
# Log 日志相关
logging:path: /var/logsfile: demo.log
# Other 自定义
author: chung
addr: http://example.cn/activity/5a444c451f6ee91a25846ac1

  但是以上两种写法都有同一个弊端：项目里面自定义配置项往往会有很多，频繁使用@Value注入将给项目的后期维护带来极大不便。这个时候，我们就可以建立一个属性对象，利用@ConfigurationProperties注解来绑定属性，有效简化繁杂的注入操作。例如：

# Other
paper:author: chungaddr: http://example.cn/activity/5a444c451f6ee91a25846ac1

@Component
// prefix对应配置文件中的前缀
@ConfigurationProperties(prefix = "paper")
public class Paper {private String author;private String addr;/***省略Getter Setter***/
}

  同理，我们可以编写如下测试代码，验证这种属性对象的方式能否正常使用。

@Resource
private Paper paper;@Test
public void test() {System.out.println("author:" + paper.getAuthor() + " addr:" + paper.getAddr());
}

  可以看到，当属性越来越多，我们利用对象的方式优势也就越大，而至于.properties和.yml选哪种，就看个人喜好了。

控制器基本用法

关于 Controller

  讨论完了项目的属性配置，让我们探讨一下在 Spring Boot 中如何使用控制器。在 Spring Boot Controller 的编码中，我们常用到的注解如下：

  • 标注控制层组件的注解@Controller、@RestController
  • 配置URL映射的注解@RequestMapping
  • 获取参数的注解@PathVariable(URL中)、@RequestParam（HTTP 请求中）
  • 校验参数的注解@Valid

  相信以上那些，大家或多或少有点熟悉，其实还有一些简洁的组合注解，这些注解在配合使用RESTful API时，会非常优雅非常有逼格：

  • @GetMapping("")
  • @PostMapping("")
  • @PutMapping("")
  • @DeleteMapping("")

  而实际上，XXXMapping("YYY") 和 @RequestMapping(value = "YYY",method = RequestMethod.XXX)没有区别，点进源码一切你就会恍然大悟。
  看完这些注解，接下来我们瞧瞧怎么把它们用进控制器。先拿@Controller和@RestController来说，如果使用@Controller注解，表示控制器返回的是模板，而使用@RestController注解，则表示返回的可能是 JSON 或文本等等。
  见如下代码，编写完成后启动项目，浏览器访问 http://localhost:8080/demo/say，你会看到 Hello World！，就是这么简单粗暴，什么 Jackson 配置之类的，让框架替你解决就好了。

@RestController
public class DemoController {@RequestMapping("/say")public String sayHello() {return "Hello World!";}
}

注意：

  • 项目配置文件选择 application.properties 与 application.yml 之一即可（删掉其中一个）
  • 若上一章中没有配置 server.context-path=/demo 或者 context-path: /demo，则应访问http://localhost:8080/say
  • 添加完依赖后，右键 pom.xml→Maven→ Reimport，重新导入

  至于@Controller注解，我们常用来和模板引擎Thymeleaf一起使用，这里我们不讨论模板引擎，简单看看@Controller的使用：

  1. 在 pom 文件中导入Thymeleaf依赖（IDEA 的提示功能很强大，好好利用）
  2. 编写 Controller 代码，返回 hello 页面模板
  3. 编写页面模板 hello.html
<dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-thymeleaf</artifactId>
</dependency>

@Controller
public class DemoController {@RequestMapping("/say")public String sayHello() {return "hello";}
}

<html><head><title>Hello</title></head><body><p>Hello World!</p></body>
</html>

  同样，启动项目，访问 http://localhost:8080/demo/say，我们发现，Hello World! 还是那个 Hello World!，但是它们背后的故事可就大不相同了。

实际上，我们点进源码就会发现，@RestController其实就是@ResponseBody＋@Controller，玩到后来还是被套路了…

  再来看看控制器中其它注解的使用，就拿那几个代表性的传说中和RESTful完美搭配的那几个家伙为例，我们在@RestController注解标识的控制器中，编写如下方法：

@GetMapping("/getPaper/{id}")
public Paper getPaper(@PathVariable String id) {Paper paper = new Paper(null, "chung", new Date(), "http://example.cn/activity/" + id);return paper;
}

  其中@GetMapping表示此方法仅响应GET请求，其请求路径也附在括号内。而@PathVariable则获取了路径中的一个参数，这个参数在路径中用大括号标注。
  还要再编写实体类 Paper 如下：

public class Paper {private Integer id;private String author;private Date date;private String url;/***省略NoArgsConstructor AllArgsConstructor***//***省略Getter Setter***/
}

  此时重启项目，再访问http://localhost:8080/demo/getPaper/5a444c451f6ee91a25846ac1，就可以看到框架已经自动帮我们把对象转换为 JSON 显示在了浏览器，如下：

{"id": null,"author": "chung","date": 1514896266452,"url": "http://example.cn/activity/5a444c451f6ee91a25846ac1"
}

  在上面的例子中，我们用到了@PathVariable注解，它可以帮助我们从路径中获取参数。而与其不同的@RequestParam注解，它可以帮助我们从请求中获取参数，例如：

@GetMapping("/getPaper")
public Paper getPaperByRequestParam(@RequestParam(defaultValue = "5a444c451f6ee91a25846ac1") String id) {Paper paper = new Paper(null, "chung", new Date(), "http://example.cn/activity/" + id);return paper;
}

  此时重启项目，访问http://localhost:8080/demo/getPaper?id=5a444c451f6ee91a25846ac1也将得到同样的结果。

注意：如果缺少?id=*这段，访问时将会报错，为避免这样的问题，我们可以设置默认值@RequestParam(defaultValue = "5a444c451f6ee91a25846ac1")。

单元测试

  在上一章我们讨论了 Spring Boot 中 JUnit 的简单写法，其实，我们可以使用 IDEA 插入单元测试，这样更加便捷，省去了我们新建包、新建文件、新建类的时间，步骤如下：

  1. 在代码中选中DemoController右键→Go To→Test→Create New Test→勾选需要测试的方法→OK；
  2. 这时 IDEA 已经在 test 目录下相应的包内为我们创建好了DemoControllerTest文件；
  3. 我们使用 Spring 提供的MockMvc类来完成测试，用@AutoConfigureMockMvc注解让框架自动配置，并使用@Resource注入 MockMvc；
  4. 编写接口测试代码并打印，测试代码及结果如下两段：
@RunWith(SpringRunner.class)
@SpringBootTest
@AutoConfigureMockMvc
public class DemoControllerTest {@Resourceprivate MockMvc mockMvc;@Testpublic void getPaperByRequestParam() throws Exception {mockMvc.perform(MockMvcRequestBuilders.get("/getPaper").param("id", "5a444c451f6ee91a25846ac1")).andDo(print()).andReturn();}
}

MockHttpServletResponse:Status = 200
Error message = nullHeaders = {Content-Type=[application/json;charset=UTF-8]}Content type = application/json;charset=UTF-8Body = {"author":"chung","date":1514893447007,"url":"http://example.cn/activity/5a444c451f6ee91a25846ac1"}
Forwarded URL = null
Redirected URL = nullCookies = []

  测试结果限于篇幅，我只贴出了一小部分，在真实测试日志中我们可以看到各种详细的数据，包括返回页面 Body 体的具体内容也打印了出来。这样的测试代码简单优雅而又霸气十足有木有。

数据库基本操作

关于 Repository

  看完了与前端交互的部分，我们来讨论下 Spring Boot 在数据库操作方面，提供了哪些逆天的功能。
  提到持久化，不得不提JPA(Java Persistence API)，JPA 是一种规范或者说标准，Hibernate很好的实现了它，而我们使用到的Spring-Data-JPA则是Spring对Hibernate的整合。探讨实例之前，我们先做好如下准备：
  添加Spring-Data-JPA的依赖如下，注意：spring-boot-starter-data-jpa 千万不要写错。

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

  做好数据库相关配置，URL 和用户名密码等。其中ddl-auto: update表示对于表结构，有则更新，无则创建，show-sql: true则表示在控制台打印执行的SQL语句。

spring:datasource:driver-class-name: com.mysql.jdbc.Driverurl: jdbc:mysql://127.0.0.1:3306/dbgirlusername: rootpassword: rootjpa:hibernate:ddl-auto: updateshow-sql: true

  我们最好还是自己提前建好相关数据库和表，SQL 语句如下：

CREATE TABLE `tbl_paper` (`id` int(8) unsigned NOT NULL AUTO_INCREMENT,`author` varchar(6) DEFAULT '',`date` datetime DEFAULT NULL ON UPDATE CURRENT_TIMESTAMP,`url` varchar(255) DEFAULT '',PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

  此时，对与前面提到的 Paper 实体类，我们又有必要进行一定的改造，看下面这段，其中@Entity注解表示实体类与数据库表的映射关系，@Id标识主键，@GeneratedValue标识生成规则，默认为AUTO，这些都是常见的了。

@Entity(name = "tbl_paper")
public class Paper {@Id@GeneratedValueprivate Integer id;private String author;private Date date;private String url;/***省略NoArgsConstructor AllArgsConstructor***//***省略Getter Setter***//***省略Override toString***/
}

  完成了以上步骤，接下来的重头戏，当然是我们的DAO层代码啦。你没看错，仅仅只是将接口继承自JpaRepository就好了，<1,2>中，1为实体类，2为主键类型。至此，我们便可以进行简单的数据库CURD操作了，简单不简单？粗暴不粗暴？心动不心动？

public interface PaperRepository extends JpaRepository<Paper, Integer> {
}

单元测试

  话说回来，还是来测试测试DAO层代码吧。首先我们提前插入几条测试数据到到数据库中备用：

INSERT INTO `tbl_paper` VALUES ('1', 'chung', '2018-01-02 21:07:10', 'http://example.cn/activity/5a444c451f6ee91a25846ac1');
INSERT INTO `tbl_paper` VALUES ('2', 'chung', '2018-01-02 21:07:33', 'http://example.cn/activity/5a444c451f6ee91a25846ac1');
INSERT INTO `tbl_paper` VALUES ('3', 'charle', '2018-01-02 21:07:47', 'http://example.cn/activity/5a444c451f6ee91a25846ac1');

  接着，根据提到过的方法，自动生成测试文件，并编写代码如下，其中findAll()是框架为我们提供的查询所有数据的方法，它会返回一个实体对象的List。

@RunWith(SpringRunner.class)
@SpringBootTest
public class PaperRepositoryTest {@Resourceprivate PaperRepository paperRepository;@Testpublic void testFindAll(){List<Paper> all = paperRepository.findAll();System.out.println(all.toString());}
}

  我们可以看看测试结果，打印出的内容正是我们所插入的3条记录。

[Paper{id=1, author='chung', date=2018-01-02 21:07:10.0, url='http://example.cn/activity/5a444c451f6ee91a25846ac1'}, 
Paper{id=2, author='chung', date=2018-01-02 21:07:33.0, url='http://example.cn/activity/5a444c451f6ee91a25846ac1'}, 
Paper{id=3, author='charle', date=2018-01-02 21:07:47.0, url='http://example.cn/activity/5a444c451f6ee91a25846ac1'}]

  你也许会问，大工程里面，这么复杂的逻辑，仅仅使用框架提供的能够满足特定需求吗。不要怕，忘了告诉你，更逆天的是，JPA也支持自定义的数据库操作甚至自定义SQL语句。举个例子如下，简简单单定义好方法之后，你就可以使用它来根据author查找所有满足条件的Paper了。特别要注意的是，这个类和方法的名字可不是随便起的，它们的名称必须遵循Spring Data JPA的命名规范，而关于这个命名规范，大家可以自行查阅资料，就不在此赘述了。

public interface PaperRepository extends JpaRepository<Paper, Integer> {List<Paper> findPapersByAuthor(String author);
}

  同样，我们来测试下，这么简单的定义了一个方法之后，是否真的能够如愿满足我们的需求：

@Test
public void findPapersByAuthor() throws Exception {List<Paper> byAuthor = paperRepository.findPapersByAuthor("chung");System.out.println(byAuthor.toString());
}

  可以从打印出的内容中很明显的看到，这一次只有两个author值为chung的记录，说明我们的写法是可以完成查询特定条件的内容的。

[Paper{id=1, author='chung', date=2018-01-02 21:07:10.0, url='http://example.cn/activity/5a444c451f6ee91a25846ac1'}, 
Paper{id=2, author='chung', date=2018-01-02 21:07:33.0, url='http://example.cn/activity/5a444c451f6ee91a25846ac1'}]

  以上我们只是简单地讨论了JPA的使用，其他的CURD操作，大家可以举一反三。实际上JPA的功能远不止如此，我们可以自己写实现类来自定义操作，也可以自己写SQL语句配合@Query来查询，基本上来说，只有你想不到，没有它办不到。是不是霸气侧漏？

事务管理简介

关于Service

  前面我们讨论了和前端打交道的控制器，也讨论了和数据库打交道的持久层，是时候讨论业务层了。与Controller类似，Service类，也有一个自己的注解，叫做@Service，配合我们曾编写过的PaperRepository，我们可以编写一个简单的Service Demo，其中使用到了PaperRepository的save()，这个方法也是框架为我们提供的，代码如下：

@Service
public class PaperService {@Resourceprivate PaperRepository paperRepository;public void savePaper() {Paper paper1 = new Paper(null, "Zhang", new Date(), "http://example.cn/activity/5a444c451f6ee91a25846ac1");paperRepository.save(paper1);Paper paper2 = new Paper(1, "ZhangChong", new Date(), "http://example.cn/activity/5a444c451f6ee91a25846ac1");paperRepository.save(paper2);}
}

  这个时候我们测试PaperService的savePaper()，代码如下：

@RunWith(SpringRunner.class)
@SpringBootTest
public class PaperServiceTest {@Resourceprivate PaperService paperService;@Testpublic void savePaper() throws Exception {paperService.savePaper();}
}

  测试完成后可以发现，数据库内只增加了一条记录。没关系，还记得我们前面设计数据库的时候，特意将author字段长度设置为6，这里由于我们插入的第二个实体对象author字段超长不符要求，所以导致第二条数据插入失败了，但是这并不影响我们判断：框架为我们提供的save()确实可用，而且一般情况下，添加异常处理之后，简单的Service层代码这么写，是没有问题的。

关于事务管理

  很多时候，我们的业务层逻辑复杂，很多操作都需要在同一事务中进行，这个时候，@Transactional注解就派上了用场。
它可以配置事务传播特性，默认是REQUIRED，@Transactional的使用也非常简单，你只需要在你的方法上加上这个注解便可：

@Service
public class PaperService {@Resourceprivate PaperRepository paperRepository;@Transactionalpublic void savePaper() {Paper paper1 = new Paper(null, "Zhang", new Date(), "http://example.cn/activity/5a444c451f6ee91a25846ac1");paperRepository.save(paper1);Paper paper2 = new Paper(1, "ZhangChong", new Date(), "http://example.cn/activity/5a444c451f6ee91a25846ac1");paperRepository.save(paper2);}
}

  依旧使用savePaper()测试方法，只不过这一次我们测试的方法添加了@Transactional注解。

Caused by: com.mysql.jdbc.MysqlDataTruncation: Data truncation: Data too long for column 'author' at row 1at com.mysql.jdbc.MysqlIO.checkErrorPacket(MysqlIO.java:3971)at com.mysql.jdbc.MysqlIO.checkErrorPacket(MysqlIO.java:3909)at com.mysql.jdbc.MysqlIO.sendCommand(MysqlIO.java:2527)at com.mysql.jdbc.MysqlIO.sqlQueryDirect(MysqlIO.java:2680)at com.mysql.jdbc.ConnectionImpl.execSQL......

  测试完我们发现，这一次日志中报错了，错误信息为Data too long for column 'author' at row 1。我们再去数据库查看，发现并没有任何新增的记录。对比上一次的测试结果可以知道，@Transactional将我们的两次插入操作置于同一事务中，当第二条数据插入失败时，进行了回滚操作，所以数据库不会有新增的记录。

拓展进阶

表单验证

  在接口开发的过程中，我们经常需要对提交的各种表单数据进行验证，这个时候，我们可以借助@Valid注解来轻松达到目的。话不多说，我们直接来看。再次改造Paper实体类，在author字段上添加@Size(min = 1, max = 6)，他为我们限定了author字段的长度为1-6，在url字段上添加@NotNull(message = "url不能为空")，它为我们限制了url不能为null，并定义了错误信息。

@Entity(name = "tbl_paper")
public class Paper {@Id@GeneratedValueprivate Integer id;@Size(min = 1, max = 6)private String author;private Date date;@NotNull(message = "url不能为空")private String url;/***省略NoArgsConstructor AllArgsConstructor***//***省略Getter Setter***//***省略Override toString***/
}

  接下来在控制器中，我们这么使用@Valid注解：

@RestController
public class DemoController {@Resourceprivate PaperService paperService;@PostMapping("/paper")public Object addPaper(@Valid Paper paper,BindingResult bindingResult) {if (bindingResult.hasErrors()) {return bindingResult.getFieldError().getDefaultMessage();} else {return paperService.savePaper(paper);}}
}

  以上@Valid伴随的BindingResult对象中，携带校验的各种信息。我们可以利用这个对象很方便的判定表单是否验证通过。让我们测试测试：

@RunWith(SpringRunner.class)
@SpringBootTest
@AutoConfigureMockMvc
public class DemoControllerTest {@Resourceprivate MockMvc mockMvc;@Testpublic void testAddPaper() throws Exception {mockMvc.perform(MockMvcRequestBuilders.post("/paper").param("author", "ZhangChong").param("date", String.valueOf(new Date())).param("url", "http://example.cn/activity/5a444c451f6ee91a25846ac1")).andDo(print()).andReturn();}
}

  从上面的测试代码中看到，我们故意调用接口插入一条不符规则的记录。然后从下面测试日志的Body = size must be between 1 and 6可以看出，提交的参数校验失败了，最后再去看看数据库，发现并没有成功添加记录。这一系列的现象或结果说明一个很简单的道理：@Valid为我们立下了汗马功劳，简化了我们各种判断与校验的工作。

MockHttpServletResponse:Status = 200
Error message = nullHeaders = {Content-Type=[text/plain;charset=UTF-8], Content-Length=[28]}Content type = text/plain;charset=UTF-8Body = size must be between 1 and 6
Forwarded URL = null
Redirected URL = nullCookies = []

天猫超市优惠地址

这篇关于Java 校招面经合集的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/1087207。

相关文章

Java五子棋之坐标校正

Java五子棋之坐标校正

上篇针对了Java项目中的解构思维，在这篇内容中我们不妨从整体项目中拆解拿出一个非常重要的五子棋逻辑实现：坐标校正，我们如何使漫无目的鼠标点击变得有序化和可控化呢？ 目录 一、从鼠标监听到获取坐标 1.MouseListener和MouseAdapter 2.mousePressed方法 二、坐标校正的具体实现方法 1.关于fillOval方法 2.坐标获取 3.坐标转换 4.坐
阅读更多...
Spring Cloud：构建分布式系统的利器

Spring Cloud：构建分布式系统的利器

引言 在当今的云计算和微服务架构时代，构建高效、可靠的分布式系统成为软件开发的重要任务。Spring Cloud 提供了一套完整的解决方案，帮助开发者快速构建分布式系统中的一些常见模式（例如配置管理、服务发现、断路器等）。本文将探讨 Spring Cloud 的定义、核心组件、应用场景以及未来的发展趋势。 什么是 Spring Cloud Spring Cloud 是一个基于 Spring
阅读更多...
Javascript高级程序设计(第四版)--学习记录之变量、内存

Javascript高级程序设计(第四版)--学习记录之变量、内存

原始值与引用值 原始值：简单的数据即基础数据类型，按值访问。 引用值：由多个值构成的对象即复杂数据类型，按引用访问。 动态属性 对于引用值而言，可以随时添加、修改和删除其属性和方法。 let person = new Object();person.name = 'Jason';person.age = 42;console.log(person.name,person.age);//'J
阅读更多...
java8的新特性之一（Java Lambda表达式）

java8的新特性之一（Java Lambda表达式）

1：Java8的新特性 Lambda 表达式： 允许以更简洁的方式表示匿名函数（或称为闭包）。可以将Lambda表达式作为参数传递给方法或赋值给函数式接口类型的变量。 Stream API： 提供了一种处理集合数据的流式处理方式，支持函数式编程风格。 允许以声明性方式处理数据集合（如List、Set等）。提供了一系列操作，如map、filter、reduce等，以支持复杂的查询和转
阅读更多...
Java面试八股之怎么通过Java程序判断JVM是32位还是64位

Java面试八股之怎么通过Java程序判断JVM是32位还是64位

怎么通过Java程序判断JVM是32位还是64位 可以通过Java程序内部检查系统属性来判断当前运行的JVM是32位还是64位。以下是一个简单的方法： public class JvmBitCheck {public static void main(String[] args) {String arch = System.getProperty("os.arch");String dataM
阅读更多...
详细分析Springmvc中的@ModelAttribute基本知识（附Demo）

详细分析Springmvc中的@ModelAttribute基本知识（附Demo）

目录 前言1. 注解用法1.1 方法参数1.2 方法1.3 类 2. 注解场景2.1 表单参数2.2 AJAX请求2.3 文件上传 3. 实战4. 总结 前言 将请求参数绑定到模型对象上，或者在请求处理之前添加模型属性 可以在方法参数、方法或者类上使用 一般适用这几种场景： 表单处理：通过 @ModelAttribute 将表单数据绑定到模型对象上预处理逻辑：在请求处理之前
阅读更多...
eclipse运行springboot项目，找不到主类

eclipse运行springboot项目，找不到主类

解决办法尝试了很多种，下载sts压缩包行不通。最后解决办法如图： help--->Eclipse Marketplace--->Popular--->找到Spring Tools 3---->Installed。
阅读更多...
JAVA读取MongoDB中的二进制图片并显示在页面上

JAVA读取MongoDB中的二进制图片并显示在页面上

1：Jsp页面： <td><img src="${ctx}/mongoImg/show"></td> 2：xml配置： <?xml version="1.0" encoding="UTF-8"?><beans xmlns="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001
阅读更多...
Java面试题：通过实例说明内连接、左外连接和右外连接的区别

Java面试题：通过实例说明内连接、左外连接和右外连接的区别

在 SQL 中，连接（JOIN）用于在多个表之间组合行。最常用的连接类型是内连接（INNER JOIN）、左外连接（LEFT OUTER JOIN）和右外连接（RIGHT OUTER JOIN）。它们的主要区别在于它们如何处理表之间的匹配和不匹配行。下面是每种连接的详细说明和示例。 表示例 假设有两个表：Customers 和 Orders。 Customers CustomerIDCus
阅读更多...
22.手绘Spring DI运行时序图

22.手绘Spring DI运行时序图

1.依赖注入发生的时间 当Spring loC容器完成了 Bean定义资源的定位、载入和解析注册以后,loC容器中已经管理类Bean 定义的相关数据，但是此时loC容器还没有对所管理的Bean进行依赖注入，依赖注入在以下两种情况 发生： 、用户第一次调用getBean()方法时，loC容器触发依赖注入。 、当用户在配置文件中将＜bean＞元素配置了 lazy-init二false属性,即让
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2