dw网站管理与建设,画册设计多少钱一页,上海网站建设中,德州加盟网站建设Springboot学习-day16
Springboot是spring家族中的一个全新框架#xff0c;用来简化spring程序的创建和开发过程。在以往我们通过SpringMVCSpringMybatis框架进行开发的时候#xff0c;我们需要配置web.xml#xff0c;spring配置#xff0c;mybatis配置#xff0c;然后整…Springboot学习-day16
Springboot是spring家族中的一个全新框架用来简化spring程序的创建和开发过程。在以往我们通过SpringMVCSpringMybatis框架进行开发的时候我们需要配置web.xmlspring配置mybatis配置然后整合在一起而springboot抛弃了繁琐的xml配置过程采用大量默认的配置来简化我们的spring开发过程。
SpringBoot化繁为简使开发变得更加的简单迅速。
1. Springboot项目搭建
1.1 maven下载和配置
下载maven的压缩包并解压
在解压后的文件夹中找到conf文件夹中的settings.xml文件配置本地库地址和配置国内镜像
!-- 配置maven本地库的位置 --
localRepositoryC:\maven\repository/localRepository!-- 配置国内镜像源 --
mirror idalimaven/id mirrorOfcentral/mirrorOf namealiyun maven/name urlhttp://maven.aliyun.com/nexus/content/groups/public//url
/mirror1.2 pom.xml
在IDEA中创建maven项目 在IDEA的setting中修改maven的配置将路径改为自己配置的maven路径以及setting.xml和本地库路径 在pom.xml文件中添加springboot依赖
dependencygroupIdorg.springframework.boot/groupIdartifactIdspring-boot-starter-web/artifactIdversion2.6.6/version
/dependency更新maven库下载完成后可以在External Libraries中看到新添加的jar包 什么是POM
pom是Project Object Model的缩写即项目对象模型。pom.xml文件用于管理源代码、配置文件、开发者的信息和角色、问题追踪系统、组织信息、项目授权、项目的url、项目的依赖关系等等。
maven的基本字段含义
project xmlnshttp://maven.apache.org/POM/4.0.0 xmlns:xsihttp://www.w3.org/2001/XMLSchema-instancexsi:schemaLocationhttp://maven.apache.org/POM/4.0.0http://maven.apache.org/maven-v4_0_0.xsdmodelVersion4.0.0/modelVersiongroupIdcom.funtl/groupIdartifactIditoken-dependencies/artifactIdversion1.0.0/versionpackagingwar/packagingnameitoken dependencies/nameurlwww.funtl.com/url
/project
字段说明modelVersion声明项目描述符遵循的哪一个POM模型版本。这是为了当Maven引入新的特性或者其他模型变更的时候确保稳定性groupId公司或者组织的唯一标识并且配置时生成的路径也是由此生成的。artifactId本项目唯一ID一个groupId下面可能多个项目就是靠artifactId来区分的version本项目目前所处的版本号packaging打包类型如pomjarrar等name项目的名称Maven产生的文档用可省略url项目主页的urlMaven产生文档用可省略
其中groupIdartifactIdversionpackaging这四项组成了项目的唯一坐标。一般情况下前面三项就足矣。
依赖项中的字段含义
dependenciesdependencygroupIdorg.springframework.boot/groupIdartifactIdspring-boot-starter-web/artifactIdversion2.6.6/version/dependency
/dependencies字段说明groupId依赖项的组织名artifactId依赖项的子项目名version依赖项的版本
约定大于配置
约定大于配置是一种设计理念它在Spring Boot框架中有广泛的应用。这一理念的核心思想是通过开发框架中定义一些默认的约定和规则从而减少开发人员需要配置的工作使开发更加高效同时提高了项目的可维护性和可读性。
1.3 启动Springboot项目
创建项目启动类名字一般为XXApplication
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;//SpringBootApplication 标识SpringBoot应用程序的入口类
SpringBootApplication
public class EasySpringAApplication {//项目启动类 运行起该类就运行了整个项目public static void main(String[] args) {//SpringApplication.run(启动类的类对象, args);SpringApplication.run(EasySpringAApplication.class, args);}
}启动成功如下图所示 可以看到上图中Started EasySpringAApplication in 1.082 seconds这代表项目已经启动成功
Tomcat started on port(s): 8080 (http) with context path 表示Tomcat已经在端口8080启动并准备接受HTTP请求with context path后是空串表示应用是部署在根目录下的访问http://localhost:8080即可访问
2. IoC
IoCInverse of Control控制反转是一种设计思想就是将原本在程序中手动创建对象的控制权交由Spring框架来管理。IoC 在其他语言中也有应用并非 Spring 特有。IoC 容器是 Spring 用来实现 IoC 的载体IoC 容器实际上就是个Mapkeyvalue,Map 中存放的是各种对象。
将对象之间的相互依赖关系交给 IoC 容器来管理并由 IoC 容器完成对象的注入。这样可以很大程度上简化应用的开发把应用从复杂的依赖关系中解放出来。 IoC 容器就像是一个工厂一样当我们需要创建一个对象的时候只需要配置好配置文件xml/注解即可完全不用考虑对象是如何被创建出来的。
优点
实现组件之间的解耦提高程序的灵活性和可维护性
缺点
对程序员来说创建对象的步骤变复杂了不直观因为使用反射来创建对象所以在效率上会有些损耗。但相对于程序的灵活性和可维护性来说这点损耗是微不足道的。缺少IDE重构的支持如果修改了类名还需到XML文件中手动修改。
3. DI
DI—Dependency Injection即“依赖注入”组件之间依赖关系由容器在运行期决定形象的说即由容器动态的将某个依赖关系注入到组件之中。**依赖注入的目的并非为软件系统带来更多功能而是为了提升组件重用的频率并为系统搭建一个灵活、可扩展的平台。**通过依赖注入机制我们只需要通过简单的配置而无需任何代码就可指定目标需要的资源完成自身的业务逻辑而不需要关心具体的资源来自何处由谁实现。
参考:http://t.csdnimg.cn/OP0ve
4. 常用注解
4.1 SpringBootApplication
SpringBootApplication注解通常被用于Spring Boot应用程序的入口类上用于启动Spring Boot应用程序。它可以简化Spring应用程序的配置和启动过程。这是一个组合注解包括了Configuration、EnableAutoConfiguration和ComponentScan三个注解。
SpringBootApplication
public class MyApplication {public static void main(String[] args) {SpringApplication.run(MyApplication.class, args);}
}4.2 Component、Repository、Service、Controller
Component是最基本的注解用于将一个普通的类标记为Spring的组件是以下三个类的父注解
Component
public class UserService {// 类的实现...
}Repository用于标记数据访问对象(DAO Date Access)通常用于与数据库交互的类。
Repository
public class UserRepositoryDao {// 数据访问的实现...
}Service用于标记服务类通常用于业务逻辑处理和组装。
Service
public class UserService {// 服务类的实现...
}Controller 用于标记控制器类通常用于 Web 应用程序中处理用户请求和返回响应。
Controller
public class UserController {// 控制器类的实现...
}这些注解的作用类似都是用来将类标记为 Spring 组件使其被 Spring 容器扫描和管理。使用它们的好处是可以使代码更加清晰和易读并在代码层面表示出组件的角色和职责。在使用时根据类的具体功能和用途选择合适的注解来标记类。同时这些注解也可以与其他注解结合使用实现更复杂的功能和特性。
4.3 Bean
Bean 是 Spring Framework 中的一个注解用于告诉 Spring 容器将被注解标记的方法的返回值作为一个 Bean 注册到容器中。
通常情况下我们需要在 Spring 容器中创建和管理对象。通过 Bean 注解我们可以自定义方法来返回或创建这些对象并将它们注册为 Spring 的 Bean使得它们可以在其他地方进行依赖注入、使用和管理。
Configuration
public class AppConfig {Beanpublic UserService userService() {return new UserServiceImpl();}
}在上述示例中Bean 注解标记了 userService() 方法该方法返回一个 UserService 对象。当 Spring 容器初始化时会调用 userService() 方法并将其返回的对象注册为一个 Bean。这样在其他需要使用 UserService 的地方可以通过依赖注入的方式获取该 Bean 的实例并使用它提供的服务。
除了简单的方法返回对象Bean 注解还支持更复杂的配置
可以通过 name 属性指定 Bean 的名称例如 Bean(name “myBean”)。可以通过 initMethod 属性指定在实例化 Bean 之后调用的初始化方法例如 Bean(initMethod “init”)。可以通过 destroyMethod 属性指定在销毁 Bean 之前调用的销毁方法例如 Bean(destroyMethod “cleanup”)。可以通过 Scope 注解指定 Bean 的作用域如单例(Scope(“singleton”))、原型(Scope(“prototype”))等。
4.4 Scope
Scope在和Component注解一起修饰在类上作为类级别注解时Scope表示该类实例的范围
在和Bean一起修饰在方法上作为方法级别注解时Scope表示该方法返回的实例的范围。
Component
Scope(prototype)
public class MyService {// 类的实现...
}在上述示例中MyService 类被标记为一个组件并使用 Scope(prototype) 注解将该组件的作用域设置为原型模式每次通过容器获取 MyService 的实例时都会创建一个新的对象。
4.5 Autowired
通过Autowired注解我们可以自动将 Spring 容器中匹配类型的 Bean 注入到目标对象中避免了手动处理依赖对象的创建和管理提高了代码的可维护性和可测试性。
RestController
public class EasyController {//该类中需要EasyService类的对象//在这个类中只需要声明我们依赖EasyService这个类就可以//而不需要通过代码主动获取EasyService类的对象//注入依赖 DI 通过识别依赖关系注入对应的对象AutowiredEasyService easyS;
}4.6 RequestMapping
RequestMapping 是 Spring Framework 中的一个注解用于映射请求的 URL 路径到控制器类或方法上。
通过 RequestMapping 注解我们可以定义控制器类或方法处理的请求 URL以及与之关联的 HTTP 请求方法、请求参数、请求头等条件。
RestController
public class EasyController {AutowiredTestA testA;RequestMapping(testB)public String testB(){testA.test();return EasyB method;}
}参考https://blog.csdn.net/weixin_55772633/article/details/131882825
5. Bean的作用域
bean的作用域就是指Spring给我们创建出的对象的存活范围在配置文件中通过bean的scope属性指定
scope对象的作用范围取值如下
取值范围说明singleton默认值单例模式只会创建一个对象prototype原型模式每次需要时都会创建一个新对象requestWEB 项目中Spring 创建一个 Bean 的对象将对象存入到 request 域中sessionWEB 项目中Spring 创建一个 Bean 的对象将对象存入到 session 域中global sessionWEB 项目中应用在 Portlet 环境如果没有 Portlet 环境那么globalSession 相当于 session
当scope取值为singleton时Bean的实例化个数只有一个当Spring核心文件加载时就会实例化配置的Bean实例
当scope取值为prototype时Bean的实例化个数就为多个当调用getBean()方法时就会实例化Bean类
当scope取值为request时会在每次http请求中生成一个新的Bean实例类类似于prototype应用场景一次http请求和响应共享Bean
当scope取值为session时会在http session中定义一个Bean实例场景用户会话中共享Bean例如可以用来记录一个用户的登录信息
6. Bean的生命周期
Bean 生命周期管理是 Spring Boot 中的关键功能之一。它负责管理应用程序中的 Java 对象这些对象被称为 Beans。Spring Boot 通过创建、配置、初始化和销毁这些 Beans 来确保应用程序的正常运行。这个功能的目的是提供一种灵活的方式使开发人员能够轻松地管理对象的生命周期从而实现高效的依赖注入和组件化开发。 实例化: 在Spring容器启动时Spring会创建配置中定义的所有Bean。这是通过类的构造方法或工厂方法来完成的 //Component(easybean)
public class EasyBean{public EasyBean(){System.out.println(1------EasyBean构造方法);}
}属性注入: 一旦Bean被实例化Spring会注入所有相关的属性包括通过构造方法或Setter方法注入的属性 //Component(easybean)
public class EasyBean{public EasyBean(){System.out.println(1------EasyBean构造方法);}TestA testA;Autowiredpublic void setTestA(TestA testA){System.out.println(2------注入属性);this.testA testA;}
}如果 Bean 实现了 BeanNameAware 接口则 Spring 调用 Bean 的 setBeanName() 方法传入当前 Bean 的 id 值。 //Component(easybean)
public class EasyBean implements BeanNameAware{public EasyBean(){System.out.println(1------EasyBean构造方法);}TestA testA;Autowiredpublic void setTestA(TestA testA){System.out.println(2------注入属性);this.testA testA;}Overridepublic void setBeanName(String s) {System.out.println(3------BeanNameAware接口的setBeanName方法 s);}
}如果 Bean 实现了 BeanFactoryAware 接口则 Spring 调用 setBeanFactory() 方法传入当前工厂实例的引用。 //Component(easybean)
public class EasyBean implements BeanNameAware, BeanFactoryAware{public EasyBean(){System.out.println(1------EasyBean构造方法);}TestA testA;Autowiredpublic void setTestA(TestA testA){System.out.println(2------注入属性);this.testA testA;}Overridepublic void setBeanName(String s) {System.out.println(3------BeanNameAware接口的setBeanName方法 s);}Overridepublic void setBeanFactory(BeanFactory beanFactory) throws BeansException {System.out.println(4------BeanFactoryAware的setBeanFactory方法 beanFactory);}
}当一个 Bean 实现了 ApplicationContextAware 接口并在 Spring 容器中被实例化时Spring 容器会自动调用该 Bean 的 setApplicationContext 方法并将应用程序上下文ApplicationContext作为参数传递进来 //Component(easybean)
public class EasyBean implements BeanNameAware, BeanFactoryAware, ApplicationContextAware{public EasyBean(){System.out.println(1------EasyBean构造方法);}TestA testA;Autowiredpublic void setTestA(TestA testA){System.out.println(2------注入属性);this.testA testA;}Overridepublic void setBeanName(String s) {System.out.println(3------BeanNameAware接口的setBeanName方法 s);}Overridepublic void setBeanFactory(BeanFactory beanFactory) throws BeansException {System.out.println(4------BeanFactoryAware的setBeanFactory方法 beanFactory);}Overridepublic void setApplicationContext(ApplicationContext applicationContext) throws BeansException {System.out.println(5------ApplicationContextAware接口的setApplicationContext方法);}
}BeanPostProcessor 是 Spring 框架中的一个重要接口它允许开发者在 Spring 容器创建和初始化 bean 的过程中对 bean 进行自定义处理。这包括在 bean 实例化之后、属性设置之前postProcessBeforeInitialization 方法以及在 bean 初始化之后postProcessAfterInitialization 方法执行自定义逻辑 Spring 容器在创建和初始化每一个 bean 时都会调用 CustomBeanPostProcessor 中的这两个方法允许你进行自定义处理 初始化之前执行postProcessBeforeInitialization方法初始化之后执行postProcessAfterInitialization方法 Component
public class EasyBeanPost implements BeanPostProcessor {Overridepublic Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {if(beanName.equals(easyBean)) System.out.println(6------BeanPostProcessor的before方法 beanName);return BeanPostProcessor.super.postProcessBeforeInitialization(bean, beanName);}
}InitializingBean 是 Spring 框架中的一个接口它定义了一个 afterPropertiesSet 方法。当 Spring 容器创建 bean 的所有属性都被设置完成后会调用这个方法。 //Component(easybean)
public class EasyBean implements BeanNameAware, BeanFactoryAware, ApplicationContextAware, InitializingBean{public EasyBean(){System.out.println(1------EasyBean构造方法);}TestA testA;Autowiredpublic void setTestA(TestA testA){System.out.println(2------注入属性);this.testA testA;}Overridepublic void setBeanName(String s) {System.out.println(3------BeanNameAware接口的setBeanName方法 s);}Overridepublic void setBeanFactory(BeanFactory beanFactory) throws BeansException {System.out.println(4------BeanFactoryAware的setBeanFactory方法 beanFactory);}Overridepublic void setApplicationContext(ApplicationContext applicationContext) throws BeansException {System.out.println(5------ApplicationContextAware接口的setApplicationContext方法);}Overridepublic void afterPropertiesSet() throws Exception {System.out.println(7-----InitializingBean接口的afterPropertiesSet方法);}
}如果在配置文件中通过 init-method 属性指定了初始化方法则调用该初始化方法。 //Component(easybean)
public class EasyBean implements BeanNameAware, BeanFactoryAware, ApplicationContextAware, InitializingBean{public EasyBean(){System.out.println(1------EasyBean构造方法);}TestA testA;Autowiredpublic void setTestA(TestA testA){System.out.println(2------注入属性);this.testA testA;}Overridepublic void setBeanName(String s) {System.out.println(3------BeanNameAware接口的setBeanName方法 s);}Overridepublic void setBeanFactory(BeanFactory beanFactory) throws BeansException {System.out.println(4------BeanFactoryAware的setBeanFactory方法 beanFactory);}Overridepublic void setApplicationContext(ApplicationContext applicationContext) throws BeansException {System.out.println(5------ApplicationContextAware接口的setApplicationContext方法);}Overridepublic void afterPropertiesSet() throws Exception {System.out.println(7-----InitializingBean接口的afterPropertiesSet方法);}public void initMethod(){System.out.println(8------initMethod方法);}
}Configuration
public class EastConfiguration {Bean(initMethod initMethod)public EasyBean easyBean(){return new EasyBean();}
}如果 BeanPostProcessor 和 Bean 关联则 Spring 将调用该接口的初始化方法postProcessAfterInitialization()。此时Bean 已经可以被应用系统使用了。 Component
public class EasyBeanPost implements BeanPostProcessor {Overridepublic Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {if(beanName.equals(easyBean)) System.out.println(6------BeanPostProcessor的before方法 beanName);return BeanPostProcessor.super.postProcessBeforeInitialization(bean, beanName);}Overridepublic Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {if(beanName.equals(easyBean)) System.out.println(9------BeanPostProcessor的after方法);return BeanPostProcessor.super.postProcessAfterInitialization(bean, beanName);}
}如果在 bean 中指定了该 Bean 的作用范围为 scope“singleton”则将该 Bean 放入 Spring IoC 的缓存池中将触发 Spring 对该 Bean 的生命周期管理如果在 bean 中指定了该 Bean 的作用范围为 scope“prototype”则将该 Bean 交给调用者调用者管理该 Bean 的生命周期Spring 不再管理该 Bean。 Configuration
public class EastConfiguration {Bean(initMethod initMethod)//Scope(prototype)public EasyBean easyBean(){return new EasyBean();}
}如果 Bean 实现了 DisposableBean 接口则 Spring 会调用 destory() 方法将 Spring 中的 Bean 销毁如果在配置文件中通过 destory-method 属性指定了 Bean 的销毁方法则 Spring 将调用该方法对 Bean 进行销毁。 EasyBean类 //Component(easybean)
public class EasyBean implements BeanNameAware, BeanFactoryAware, ApplicationContextAware, InitializingBean, DisposableBean {public EasyBean(){System.out.println(1------EasyBean构造方法);}TestA testA;Autowiredpublic void setTestA(TestA testA){System.out.println(2------注入属性);this.testA testA;}Overridepublic void setBeanName(String s) {System.out.println(3------BeanNameAware接口的setBeanName方法 s);}Overridepublic void setBeanFactory(BeanFactory beanFactory) throws BeansException {System.out.println(4------BeanFactoryAware的setBeanFactory方法 beanFactory);}Overridepublic void setApplicationContext(ApplicationContext applicationContext) throws BeansException {System.out.println(5------ApplicationContextAware接口的setApplicationContext方法);}Overridepublic void afterPropertiesSet() throws Exception {System.out.println(7-----InitializingBean接口的afterPropertiesSet方法);}public void initMethod(){System.out.println(8------initMethod方法);}Overridepublic void destroy() throws Exception {System.out.println(10------easyBean被回收了);}
}EasyBeanPost类 Component
public class EasyBeanPost implements BeanPostProcessor {Overridepublic Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {if(beanName.equals(easyBean)) System.out.println(6------BeanPostProcessor的before方法 beanName);return BeanPostProcessor.super.postProcessBeforeInitialization(bean, beanName);}Overridepublic Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {if(beanName.equals(easyBean)) System.out.println(9------BeanPostProcessor的after方法);return BeanPostProcessor.super.postProcessAfterInitialization(bean, beanName);}
}EasyConfiguration类 Configuration
public class EastConfiguration {Bean(initMethod initMethod)//Scope(prototype)public EasyBean easyBean(){return new EasyBean();}
}执行结果如下图所示
