Spring三十五问,四万字+五十图详解 建议收藏
这节我们来搞定另一个面试必问知识点——Spring。
有人说,“Java程序员都是Spring程序员”,老三不太赞成这个观点,但是这也可以看出Spring在Java世界里举足轻重的作用。
附面试思维导图(仅供参考)
基础
1.Spring是什么?特性?有哪些模块?
一句话概括:Spring 是一个轻量级、非入侵式的控制反转 (IoC) 和面向切面 (AOP) 的框架。
2003年,一个音乐家Rod Johnson决定发展一个轻量级的Java开发框架,Spring
作为Java战场的龙骑兵渐渐崛起,并淘汰了EJB
这个传统的重装骑兵。
Spring重要版本
到了现在,企业级开发的标配基本就是 Spring5 + Spring Boot 2 + JDK 8
Spring有哪些特性呢?
Spring有很多优点:
1、IOC 和 DI 的支持
Spring 的核心就是一个大的工厂容器,可以维护所有对象的创建和依赖关系,Spring 工厂用于生成 Bean,并且管理 Bean 的生命周期,实现高内聚低耦合的设计理念。
2、AOP 编程的支持
Spring 提供了面向切面编程,可以方便的实现对程序进行权限拦截、运行监控等切面功能。
3、声明式事务的支持
支持通过配置就来完成对事务的管理,而不需要通过硬编码的方式,以前重复的一些事务提交、回滚的JDBC代码,都可以不用自己写了。
4、快捷测试的支持
Spring 对 Junit 提供支持,可以通过注解快捷地测试 Spring 程序。
5、快速集成功能
方便集成各种优秀框架,Spring 不排斥各种优秀的开源框架,其内部提供了对各种优秀框架(如:Struts、Hibernate、MyBatis、Quartz 等)的直接支持。
6、复杂API模板封装
Spring 对 JavaEE 开发中非常难用的一些 API(JDBC、JavaMail、远程调用等)都提供了模板化的封装,这些封装 API 的提供使得应用难度大大降低。
2.Spring有哪些模块呢?
Spring 框架是分模块存在,除了最核心的Spring Core Container
是必要模块之外,其他模块都是可选
,大约有 20 多个模块。
最主要的七大模块:
Spring Core:Spring 核心,它是框架最基础的部分,提供 IOC 和依赖注入 DI 特性。
Spring Context:Spring 上下文容器,它是 BeanFactory 功能加强的一个子接口。
Spring Web:它提供 Web 应用开发的支持。
Spring MVC:它针对 Web 应用中 MVC 思想的实现。
Spring DAO:提供对 JDBC 抽象层,简化了 JDBC 编码,同时,编码更具有健壮性。
Spring ORM:它支持用于流行的 ORM 框架的整合,比如:Spring + Hibernate、Spring + iBatis、Spring + JDO 的整合等。
Spring AOP:即面向切面编程,它提供了与 AOP 联盟兼容的编程实现。
3.Spring有哪些常用注解呢?
Spring有很多模块,甚至广义的SpringBoot、SpringCloud也算是Spring的一部分,我们来分模块,按功能来看一下一些常用的注解:
Web:
@Controller:组合注解(组合了@Component注解),应用在MVC层(控制层)。
@RestController:该注解为一个组合注解,相当于@Controller和@ResponseBody的组合,注解在类上,意味着,该Controller的所有方法都默认加上了@ResponseBody。
@RequestMapping:用于映射Web请求,包括访问路径和参数。如果是Restful风格接口,还可以根据请求类型使用不同的注解:
@GetMapping
@PostMapping
@PutMapping
@DeleteMapping
@ResponseBody:支持将返回值放在response内,而不是一个页面,通常用户返回json数据。
@RequestBody:允许request的参数在request体中,而不是在直接连接在地址后面。
@PathVariable:用于接收路径参数,比如@RequestMapping(“/hello/{name}”)申明的路径,将注解放在参数中前,即可获取该值,通常作为Restful的接口实现方法。
@RestController:该注解为一个组合注解,相当于@Controller和@ResponseBody的组合,注解在类上,意味着,该Controller的所有方法都默认加上了@ResponseBody。
容器:
@Component:表示一个带注释的类是一个“组件”,成为Spring管理的Bean。当使用基于注解的配置和类路径扫描时,这些类被视为自动检测的候选对象。同时@Component还是一个元注解。
@Service:组合注解(组合了@Component注解),应用在service层(业务逻辑层)。
@Repository:组合注解(组合了@Component注解),应用在dao层(数据访问层)。
@Autowired:Spring提供的工具(由Spring的依赖注入工具(BeanPostProcessor、BeanFactoryPostProcessor)自动注入)。
@Qualifier:该注解通常跟 @Autowired 一起使用,当想对注入的过程做更多的控制,@Qualifier 可帮助配置,比如两个以上相同类型的 Bean 时 Spring 无法抉择,用到此注解
@Configuration:声明当前类是一个配置类(相当于一个Spring配置的xml文件)
@Value:可用在字段,构造器参数跟方法参数,指定一个默认值,支持 #{} 跟 ${} 两个方式。一般将 SpringbBoot 中的 application.properties 配置的属性值赋值给变量。
@Bean:注解在方法上,声明当前方法的返回值为一个Bean。返回的Bean对应的类中可以定义init()方法和destroy()方法,然后在@Bean(initMethod=”init”,destroyMethod=”destroy”)定义,在构造之后执行init,在销毁之前执行destroy。
@Scope:定义我们采用什么模式去创建Bean(方法上,得有@Bean) 其设置类型包括:Singleton 、Prototype、Request 、 Session、GlobalSession。
AOP:
@Aspect:声明一个切面(类上) 使用@After、@Before、@Around定义建言(advice),可直接将拦截规则(切点)作为参数。
@After
:在方法执行之后执行(方法上)。@Before
:在方法执行之前执行(方法上)。@Around
:在方法执行之前与之后执行(方法上)。@PointCut
:声明切点 在java配置类中使用@EnableAspectJAutoProxy注解开启Spring对AspectJ代理的支持(类上)。
事务:
@Transactional:在要开启事务的方法上使用@Transactional注解,即可声明式开启事务。
4.Spring 中应用了哪些设计模式呢?
Spring 框架中广泛使用了不同类型的设计模式,下面我们来看看到底有哪些设计模式?
工厂模式 : Spring 容器本质是一个大工厂,使用工厂模式通过 BeanFactory、ApplicationContext 创建 bean 对象。
代理模式 : Spring AOP 功能功能就是通过代理模式来实现的,分为动态代理和静态代理。
单例模式 : Spring 中的 Bean 默认都是单例的,这样有利于容器对Bean的管理。
模板模式 : Spring 中 JdbcTemplate、RestTemplate 等以 Template结尾的对数据库、网络等等进行操作的模板类,就使用到了模板模式。
观察者模式: Spring 事件驱动模型就是观察者模式很经典的一个应用。
适配器模式 :Spring AOP 的增强或通知 (Advice) 使用到了适配器模式、Spring MVC 中也是用到了适配器模式适配 Controller。
策略模式:Spring中有一个Resource接口,它的不同实现类,会根据不同的策略去访问资源。
IOC
5.说一说什么是IOC?什么是DI?
Java 是面向对象的编程语言,一个个实例对象相互合作组成了业务逻辑,原来,我们都是在代码里创建对象和对象的依赖。
所谓的IOC(控制反转):就是由容器来负责控制对象的生命周期和对象间的关系。以前是我们想要什么,就自己创建什么,现在是我们需要什么,容器就给我们送来什么。
引入IOC之前和引入IOC之后
也就是说,控制对象生命周期的不再是引用它的对象,而是容器。对具体对象,以前是它控制其它对象,现在所有对象都被容器控制,所以这就叫控制反转。
控制反转示意图
DI(依赖注入):指的是容器在实例化对象的时候把它依赖的类注入给它。有的说法IOC和DI是一回事,有的说法是IOC是思想,DI是IOC的实现。
为什么要使用IOC呢?
最主要的是两个字解耦,硬编码会造成对象间的过度耦合,使用IOC之后,我们可以不用关心对象间的依赖,专心开发应用就行。
6.能简单说一下Spring IOC的实现机制吗?
PS:这道题老三在面试中被问到过,问法是“你有自己实现过简单的Spring吗?”
Spring的IOC本质就是一个大工厂,我们想想一个工厂是怎么运行的呢?
生产产品:一个工厂最核心的功能就是生产产品。在Spring里,不用Bean自己来实例化,而是交给Spring,应该怎么实现呢?——答案毫无疑问,反射。
那么这个厂子的生产管理是怎么做的?你应该也知道——工厂模式。
库存产品:工厂一般都是有库房的,用来库存产品,毕竟生产的产品不能立马就拉走。Spring我们都知道是一个容器,这个容器里存的就是对象,不能每次来取对象,都得现场来反射创建对象,得把创建出的对象存起来。
订单处理:还有最重要的一点,工厂根据什么来提供产品呢?订单。这些订单可能五花八门,有线上签签的、有到工厂签的、还有工厂销售上门签的……最后经过处理,指导工厂的出货。
在Spring里,也有这样的订单,它就是我们bean的定义和依赖关系,可以是xml形式,也可以是我们最熟悉的注解形式。
我们简单地实现一个mini版的Spring IOC:
Bean定义:
Bean通过一个配置文件定义,把它解析成一个类型。
beans.properties
偷懒,这里直接用了最方便解析的properties,这里直接用一个<key,value>类型的配置来代表Bean的定义,其中key是beanName,value是class
userDao:cn.fighter3.bean.UserDao
BeanDefinition.java
bean定义类,配置文件中bean定义对应的实体
public class BeanDefinition {private String beanName;private Class beanClass;//省略getter、setter }
ResourceLoader.java
资源加载器,用来完成配置文件中配置的加载
public class ResourceLoader {public static Map<String, BeanDefinition> getResource() {Map<String, BeanDefinition> beanDefinitionMap = new HashMap<>(16);Properties properties = new Properties();try {InputStream inputStream = ResourceLoader.class.getResourceAsStream("/beans.properties");properties.load(inputStream);Iterator<String> it = properties.stringPropertyNames().iterator();while (it.hasNext()) {String key = it.next();String className = properties.getProperty(key);BeanDefinition beanDefinition = new BeanDefinition();beanDefinition.setBeanName(key);Class clazz = Class.forName(className);beanDefinition.setBeanClass(clazz);beanDefinitionMap.put(key, beanDefinition);}inputStream.close();} catch (IOException | ClassNotFoundException e) {e.printStackTrace();}return beanDefinitionMap;}}
BeanRegister.java
对象注册器,这里用于单例bean的缓存,我们大幅简化,默认所有bean都是单例的。可以看到所谓单例注册,也很简单,不过是往HashMap里存对象。
public class BeanRegister {//单例Bean缓存private Map<String, Object> singletonMap = new HashMap<>(32);/*** 获取单例Bean** @param beanName bean名称* @return*/public Object getSingletonBean(String beanName) {return singletonMap.get(beanName);}/*** 注册单例bean** @param beanName* @param bean*/public void registerSingletonBean(String beanName, Object bean) {if (singletonMap.containsKey(beanName)) {return;}singletonMap.put(beanName, bean);}}
BeanFactory.java
BeanFactory
对象工厂,我们最核心的一个类,在它初始化的时候,创建了bean注册器,完成了资源的加载。
获取bean的时候,先从单例缓存中取,如果没有取到,就创建并注册一个bean
public class BeanFactory {private Map<String, BeanDefinition> beanDefinitionMap = new HashMap<>();private BeanRegister beanRegister;public BeanFactory() {//创建bean注册器beanRegister = new BeanRegister();//加载资源this.beanDefinitionMap = new ResourceLoader().getResource();}/*** 获取bean** @param beanName bean名称* @return*/public Object getBean(String beanName) {//从bean缓存中取Object bean = beanRegister.getSingletonBean(beanName);if (bean != null) {return bean;}//根据bean定义,创建beanreturn createBean(beanDefinitionMap.get(beanName));}/*** 创建Bean** @param beanDefinition bean定义* @return*/private Object createBean(BeanDefinition beanDefinition) {try {Object bean = beanDefinition.getBeanClass().newInstance();//缓存beanbeanRegister.registerSingletonBean(beanDefinition.getBeanName(), bean);return bean;} catch (InstantiationException | IllegalAccessException e) {e.printStackTrace();}return null;} }
测试
UserDao.java
我们的Bean类,很简单
public class UserDao {public void queryUserInfo(){System.out.println("A good man.");} }
单元测试
public class ApiTest {@Testpublic void test_BeanFactory() {//1.创建bean工厂(同时完成了加载资源、创建注册单例bean注册器的操作)BeanFactory beanFactory = new BeanFactory();//2.第一次获取bean(通过反射创建bean,缓存bean)UserDao userDao1 = (UserDao) beanFactory.getBean("userDao");userDao1.queryUserInfo();//3.第二次获取bean(从缓存中获取bean)UserDao userDao2 = (UserDao) beanFactory.getBean("userDao");userDao2.queryUserInfo();} }
运行结果
A good man. A good man.
至此,我们一个乞丐+破船版的Spring就完成了,代码也比较完整,有条件的可以跑一下。
PS:因为时间+篇幅的限制,这个demo比较简陋,没有面向接口、没有解耦、边界检查、异常处理……健壮性、扩展性都有很大的不足,感兴趣可以学习参考[15]。
7.说说BeanFactory和ApplicantContext?
可以这么形容,BeanFactory是Spring的“心脏”,ApplicantContext是完整的“身躯”。
BeanFactory(Bean工厂)是Spring框架的基础设施,面向Spring本身。
ApplicantContext(应用上下文)建立在BeanFactoty基础上,面向使用Spring框架的开发者。
BeanFactory 接口
BeanFactory是类的通用工厂,可以创建并管理各种类的对象。
Spring为BeanFactory提供了很多种实现,最常用的是XmlBeanFactory,但在Spring 3.2中已被废弃,建议使用XmlBeanDefinitionReader、DefaultListableBeanFactory。
BeanFactory接口位于类结构树的顶端,它最主要的方法就是getBean(String var1),这个方法从容器中返回特定名称的Bean。
BeanFactory的功能通过其它的接口得到了不断的扩展,比如AbstractAutowireCapableBeanFactory定义了将容器中的Bean按照某种规则(比如按名字匹配、按类型匹配等)进行自动装配的方法。
这里看一个 XMLBeanFactory(已过期) 获取bean 的例子:
public class HelloWorldApp{ public static void main(String[] args) { BeanFactory factory = new XmlBeanFactory (new ClassPathResource("beans.xml")); HelloWorld obj = (HelloWorld) factory.getBean("helloWorld"); obj.getMessage(); }
}
ApplicationContext 接口
ApplicationContext由BeanFactory派生而来,提供了更多面向实际应用的功能。可以这么说,使用BeanFactory就是手动档,使用ApplicationContext就是自动档。
ApplicationContext 继承了HierachicalBeanFactory和ListableBeanFactory接口,在此基础上,还通过其他的接口扩展了BeanFactory的功能,包括:
Bean instantiation/wiring
Bean 的实例化/串联
自动的 BeanPostProcessor 注册
自动的 BeanFactoryPostProcessor 注册
方便的 MessageSource 访问(i18n)
ApplicationEvent 的发布与 BeanFactory 懒加载的方式不同,它是预加载,所以,每一个 bean 都在 ApplicationContext 启动之后实例化
这是 ApplicationContext 的使用例子:
public class HelloWorldApp{ public static void main(String[] args) { ApplicationContext context=new ClassPathXmlApplicationContext("beans.xml"); HelloWorld obj = (HelloWorld) context.getBean("helloWorld"); obj.getMessage(); }
}
ApplicationContext 包含 BeanFactory 的所有特性,通常推荐使用前者。
8.你知道Spring容器启动阶段会干什么吗?
PS:这道题老三面试被问到过
Spring的IOC容器工作的过程,其实可以划分为两个阶段:容器启动阶段和Bean实例化阶段。
其中容器启动阶段主要做的工作是加载和解析配置文件,保存到对应的Bean定义中。
容器启动开始,首先会通过某种途径加载Congiguration MetaData,在大部分情况下,容器需要依赖某些工具类(BeanDefinitionReader)对加载的Congiguration MetaData进行解析和分析,并将分析后的信息组为相应的BeanDefinition。
xml配置信息映射注册过程
最后把这些保存了Bean定义必要信息的BeanDefinition,注册到相应的BeanDefinitionRegistry,这样容器启动就完成了。
9.能说一下Spring Bean生命周期吗?
可以看看:Spring Bean生命周期,好像人的一生。。
在Spring中,基本容器BeanFactory和扩展容器ApplicationContext的实例化时机不太一样,BeanFactory采用的是延迟初始化的方式,也就是只有在第一次getBean()的时候,才会实例化Bean;ApplicationContext启动之后会实例化所有的Bean定义。
Spring IOC 中Bean的生命周期大致分为四个阶段:实例化(Instantiation)、属性赋值(Populate)、初始化(Initialization)、销毁(Destruction)。
Bean生命周期四个阶段
我们再来看一个稍微详细一些的过程:
实例化:第 1 步,实例化一个 Bean 对象
属性赋值:第 2 步,为 Bean 设置相关属性和依赖
初始化:初始化的阶段的步骤比较多,5、6步是真正的初始化,第 3、4 步为在初始化前执行,第 7 步在初始化后执行,初始化完成之后,Bean就可以被使用了
销毁:第 8~10步,第8步其实也可以算到销毁阶段,但不是真正意义上的销毁,而是先在使用前注册了销毁的相关调用接口,为了后面第9、10步真正销毁 Bean 时再执行相应的方法
简单总结一下,Bean生命周期里初始化的过程相对步骤会多一些,比如前置、后置的处理。
最后通过一个实例来看一下具体的细节:
定义一个
PersonBean
类,实现DisposableBean
,InitializingBean
,BeanFactoryAware
,BeanNameAware
这4个接口,同时还有自定义的init-method
和destroy-method
。
public class PersonBean implements InitializingBean, BeanFactoryAware, BeanNameAware, DisposableBean {/*** 身份证号*/private Integer no;/*** 姓名*/private String name;public PersonBean() {System.out.println("1.调用构造方法:我出生了!");}public Integer getNo() {return no;}public void setNo(Integer no) {this.no = no;}public String getName() {return name;}public void setName(String name) {this.name = name;System.out.println("2.设置属性:我的名字叫"+name);}@Overridepublic void setBeanName(String s) {System.out.println("3.调用BeanNameAware#setBeanName方法:我要上学了,起了个学名");}@Overridepublic void setBeanFactory(BeanFactory beanFactory) throws BeansException {System.out.println("4.调用BeanFactoryAware#setBeanFactory方法:选好学校了");}@Overridepublic void afterPropertiesSet() throws Exception {System.out.println("6.InitializingBean#afterPropertiesSet方法:入学登记");}public void init() {System.out.println("7.自定义init方法:努力上学ing");}@Overridepublic void destroy() throws Exception {System.out.println("9.DisposableBean#destroy方法:平淡的一生落幕了");}public void destroyMethod() {System.out.println("10.自定义destroy方法:睡了,别想叫醒我");}public void work(){System.out.println("Bean使用中:工作,只有对社会没有用的人才放假。。");}}
定义一个
MyBeanPostProcessor
实现BeanPostProcessor
接口。public class MyBeanPostProcessor implements BeanPostProcessor {@Overridepublic Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {System.out.println("5.BeanPostProcessor.postProcessBeforeInitialization方法:到学校报名啦");return bean;}@Overridepublic Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {System.out.println("8.BeanPostProcessor#postProcessAfterInitialization方法:终于毕业,拿到毕业证啦!");return bean;} }
配置文件,指定
init-method
和destroy-method
属性<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd"><bean name="myBeanPostProcessor" class="cn.fighter3.spring.life.MyBeanPostProcessor" /><bean name="personBean" class="cn.fighter3.spring.life.PersonBean"init-method="init" destroy-method="destroyMethod"><property name="idNo" value= "80669865"/><property name="name" value="张铁钢" /></bean></beans>
测试
public class Main {public static void main(String[] args) {ApplicationContext context = new ClassPathXmlApplicationContext("spring-config.xml");PersonBean personBean = (PersonBean) context.getBean("personBean");personBean.work();((ClassPathXmlApplicationContext) context).destroy();} }
运行结果:
1.调用构造方法:我出生了! 2.设置属性:我的名字叫张铁钢 3.调用BeanNameAware#setBeanName方法:我要上学了,起了个学名 4.调用BeanFactoryAware#setBeanFactory方法:选好学校了 5.BeanPostProcessor#postProcessBeforeInitialization方法:到学校报名啦 6.InitializingBean#afterPropertiesSet方法:入学登记 7.自定义init方法:努力上学ing 8.BeanPostProcessor#postProcessAfterInitialization方法:终于毕业,拿到毕业证啦! Bean使用中:工作,只有对社会没有用的人才放假。。 9.DisposableBean#destroy方法:平淡的一生落幕了 10.自定义destroy方法:睡了,别想叫醒我
关于源码,Bean创建过程可以查看
AbstractBeanFactory#doGetBean
方法,在这个方法里可以看到Bean的实例化,赋值、初始化的过程,至于最终的销毁,可以看看ConfigurableApplicationContext#close()
。
......
33.如何自定义一个SpringBoot Srarter?
知道了自动配置原理,创建一个自定义SpringBoot Starter也很简单。
创建一个项目,命名为demo-spring-boot-starter,引入SpringBoot相关依赖
<dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter</artifactId></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-configuration-processor</artifactId><optional>true</optional></dependency>
2.编写配置文件
这里定义了属性配置的前缀
@ConfigurationProperties(prefix = "hello")
public class HelloProperties {private String name;//省略getter、setter
}
3.自动装配
创建自动配置类HelloPropertiesConfigure
@Configuration
@EnableConfigurationProperties(HelloProperties.class)
public class HelloPropertiesConfigure {
}
4.配置自动类
在/resources/META-INF/spring.factories
文件中添加自动配置类路径
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\cn.fighter3.demo.starter.configure.HelloPropertiesConfigure
35.对SpringCloud了解多少?
SpringCloud是Spring官方推出的微服务治理框架。
Spring Cloud Netfilx核心组件-来源参考[2]
什么是微服务?
2014 年 Martin Fowler 提出的一种新的架构形式。微服务架构是一种架构模式,提倡将单一应用程序划分成一组小的服务,服务之间相互协调,互相配合,为用户提供最终价值。每个服务运行在其独立的进程中,服务与服务之间采用轻量级的通信机制(如HTTP或Dubbo)互相协作,每个服务都围绕着具体的业务进行构建,并且能够被独立的部署到生产环境中,另外,应尽量避免统一的,集中式的服务管理机制,对具体的一个服务而言,应根据业务上下文,选择合适的语言、工具(如Maven)对其进行构建。
微服务化的核心就是将传统的一站式应用,根据业务拆分成一个一个的服务,彻底地去耦合,每一个微服务提供单个业务功能的服务,一个服务做一件事情,从技术角度看就是一种小而独立的处理过程,类似进程的概念,能够自行单独启动或销毁,拥有自己独立的数据库。
微服务架构主要要解决哪些问题?
服务很多,客户端怎么访问,如何提供对外网关?
这么多服务,服务之间如何通信? HTTP还是RPC?
这么多服务,如何治理? 服务的注册和发现。
服务挂了怎么办?熔断机制。
有哪些主流微服务框架?
Spring Cloud Netflix
Spring Cloud Alibaba
SpringBoot + Dubbo + ZooKeeper
SpringCloud有哪些核心组件?
PS:微服务后面有机会再扩展,其实面试一般都是结合项目去问。
Spring三十五问,四万字+五十图详解 建议收藏相关推荐
- TCP三次握手、四次挥手以及TIME_WAIT详解
前提概述 TCP网络编程中常用的api函数有: socket.bind.listen.accept.recv.send.close.connect 其中socket函数返回一个文件描述符fd,这个fd ...
- 三次握手和四次挥手图解_详解 TCP 连接的“三次握手”与“四次挥手”
作者 | AhuntSun 责编 | Elle TCP connection 客户端与服务器之间数据的发送和返回的过程当中需要创建一个叫TCP connection的东西: 由于TCP不存在连接的概念 ...
- P2669 金币,国王将金币作为工资,发放给忠诚的骑士。第一天,骑士收到一枚金币;之后两天(第二天和第三天),每天收到两枚金币;之后三天(第四、五、六天),每天收到三枚金币;之后四天(第七、八、九、十
题目描述 国王将金币作为工资,发放给忠诚的骑士.第一天,骑士收到一枚金币:之后两天(第二天和第三天),每天收到两枚金币:之后三天(第四.五.六天),每天收到三枚金币:之后四天(第七.八.九.十天),每 ...
- 国王将金币作为工资,发放给忠诚的骑士。第一天,骑士收到一枚金币;之后两天(第二天和第三天)里,每天收到两枚金币;之后三天(第四、五、六天)里,每天收到三枚金币;之后四天(第七、八、九、十天)里
描述 国王将金币作为工资,发放给忠诚的骑士.第一天,骑士收到一枚金币:之后两天(第二天和第三天)里,每天收到两枚金币:之后三天(第四.五.六天)里,每天收到三枚金币:之后四天(第七.八.九.十天)里, ...
- Mybatis系列全解(五):全网最全!详解Mybatis的Mapper映射文件
封面:洛小汐 作者:潘潘 若不是生活所迫,谁愿意背负一身才华. 前言 上节我们介绍了 < Mybatis系列全解(四):全网最全!Mybatis配置文件 XML 全貌详解 >,内容很详细( ...
- 多图详解Spring框架的设计理念与设计模式
Spring作为现在最优秀的框架之一,已被广泛的使用,51CTO也曾经针对Spring框架中的JDBC应用做过报道.本文将从另外一个视角试图剖析出Spring框架的作者设计Spring框架的骨骼架构的 ...
- 一周刷爆LeetCode,算法da神左神(左程云)耗时100天打造算法与数据结构基础到高级全家桶教程,直击BTAJ等一线大厂必问算法面试题真题详解 笔记
一周刷爆LeetCode,算法大神左神(左程云)耗时100天打造算法与数据结构基础到高级全家桶教程,直击BTAJ等一线大厂必问算法面试题真题详解 笔记 教程与代码地址 P1 出圈了!讲课之外我们来聊聊 ...
- 树和二叉树(四种遍历,建树)详解+二叉排序树(包含图像和相关习题)
目录 树和二叉树 一.树 2.有序树和无序树 3.森林 4.树的基本性质 二.二叉树的概念 (1)二叉树的编号 1.二叉树和度为2的有序树的区别: 2.满二叉树 3.完全二叉树: 4.平衡二叉树: 5 ...
- python可变参数_Python 的四种共享传参详解
点击上方"Python数据之道",选择"星标公众号" 精品文章,第一时间送达 作者 | 杨仁聪 编辑 | Lemon 出品 | Python数据之道 本文来自公 ...
最新文章
- jdk8中流的使用(二)
- currentThread()方法的作用
- pythongui程序,python第一个GUI程序
- python pyquery库_python解析HTML之:PyQuery库的介绍与使用
- C++ Maps MultiMaps
- 微海鼠标自动点击器 支持录制和循环播放
- 熟练掌握git撤销命令
- redis集群如何解决重启不了的问题
- 如何量化考核技术人的KPI?
- 【王道操作系统笔记】进程定义组成组织方式特征
- MySQL_采购入库价格与在线售价监控_20161213
- IE7下用ajax动态填充select框的一个问题
- 最新手机号码、电话号码正则表达式
- 解决模拟人生3(SIM 3)闪退问题
- 个人作业——软件产品案例分析
- java关于int极限值的测试
- Hibernate_9_Person和IdCard实例_一对一关系:基于主键
- excel php时间,excel时间函数
- 《方块方舟》自定义服务器工具,方舟方块世界怎么自建服务器 自建服务器方法内容详解-游侠网...
- 杂项题(MISC)和web安全题【1】
热门文章
- IE6、IE7、IE8之IE多版本共存的几种方法
- 4.2 Lebesgue 积分的性质定理
- SSH服务端配置、优化加速、安全防护
- LindedList相关介绍
- 前途汽车2022策略规划正式公布,潜精研思开启品牌崭新篇章
- 最新 || 精容数安数据保护解决方案
- Tomcat 启动时报 java.net.BindException: Address already in use[localhost:8005]
- VUE利用transition标签实现摇一摇抽签效果
- rm -rf / 好屌!
- 中控 X638考勤机编程(delphi)