当前位置：首页 > news >正文

杭州雄飞网站建设网络公司热搜榜百度一下你就知道

news 2025/7/29 17:05:52

杭州雄飞网站建设网络公司,热搜榜百度一下你就知道,如何用wd做网站设计,局域网的常用技术是什么目录前言 Spring基础与核心概念 Spring是什么 1、什么是容器 2、什么是IoC 3、理解SpringIoC 4、DI（依赖注入） Spring的创建和使用 1、创建Spring项目 1.1、创建一个普通Maven项目 1.2、添加Spring框架支持 1.3、添加启动类和main方法 2、…

前言

Spring基础与核心概念

Spring是什么

1、什么是容器

2、什么是IoC

3、理解SpringIoC

4、DI（依赖注入）

Spring的创建和使用

1、创建Spring项目

1.1、创建一个普通Maven项目

1.2、添加Spring框架支持

1.3、添加启动类和main方法

2、存储Bean对象

2.1、创建Bean对象

2.2、将Bean对象存储到Spring当中

3、获取并使用Bean对象

3.1、先得到Spring上下文对象

3.2、从Spring中取出Bean对象

3.3、使用Bean

Spring更简单的读取和存储对象

1、存储Bean对象

1.1、配置扫描路径

1.2、添加注解存储Bean对象

2、获取Bean对象

2.1、属性注入

2.2、构造方法注入

2.3、Setter注入

2.4、使用@Resource（另一种注入方法）实现

Bean作用域和生命周期

1、Bean作用域定义

1.1、singleton（单例作用域）

1.2、prototype（原型作用域/多例作用域）

1.3、request（请求作用域）

1.4、session（回话作用域）

1.5、applicatioon（全局作用域）

1.6、设置作用域

2、Spring执行流程和Bean的生命周期

2.1、Spring执行流程

2.2、Bean生命周期

前言

Spring框架是一个开放源代码的J2EE应用程序框架，由Rod Johnson发起，是针对bean的生命周期进行管理的轻量级容器（lightweight container）。 Spring解决了开发者在J2EE开发中遇到的许多常见的问题，提供了功能强大IOC、AOP及Web MVC等功能。Spring可以单独应用于构筑应用程序，也可以和Struts、Webwork、Tapestry等众多Web框架组合使用，并且可以与 Swing等桌面应用程序AP组合。

Spring基础与核心概念

Spring是什么

Spring指的是Spring Framework（Spring框架），它是一个开源框架。Spring支持广泛的应用场景，它可以让java的企业级的应用程序开发起来更简单

Spring是包含了众多工具方法的IoC容器

1、什么是容器

容器是用来容纳某种物品的（基本）装置

2、什么是IoC

Inversion of Control（控制反转）

传统代码

public class App {public static void main(String[] args) {Car car=new Car(30);car.init();}
}public class Car {private Framework framework;public Car(int size){framework=new Framework(size);}public void init(){System.out.println("执行了car init方法");//依赖车身framework.init();}
}public class Framework {private Bottom bottom;public Framework(int size){bottom=new Bottom(size);}public void init(){System.out.println("执行了framework init方法");//依赖底盘bottom.init();}
}public class Bottom {private Tire tire;public Bottom(int size){tire=new Tire(size);}public void init(){System.out.println("执行了buttom init方法");//依赖轮胎tire.init();}
}public class Tire {private int size=20;public Tire(int size){this.size=size;}public void init(){System.out.println("执行了轮胎初始化方法，size："+this.size);}
}

改进后的代码

public class App {public static void main(String[] args) {Tire tire=new Tire(23);Buttom buttom=new Buttom(tire);FrameWork frameWork=new FrameWork(buttom);Car car=new Car(frameWork);car.init();}
}public class Car {private FrameWork frameWork;public Car(FrameWork frameWork){this.frameWork=frameWork;}public void init(){System.out.println("执行car");//依赖车身frameWork.init();}
}public class FrameWork {public Buttom buttom;public FrameWork(Buttom buttom){this.buttom=buttom;}public void init(){System.out.println("执行framework");//依赖车底buttom.init();}
}public class Buttom {private Tire tire;public Buttom(Tire tire){this.tire=tire;}public void init(){System.out.println("执行buttom");//依赖轮胎tire.init();}
}public class Tire {private int size=23;public Tire(int size){size=this.size;}public void init(){System.out.println("轮胎-size:"+size);}
}

当最底层代码改动之后，整个调用链上的所有代码都需要修改，解决传统开发中的缺陷

3、理解SpringIoC

Spring是一个IoC（控制反转）容器，具备两个最基础的功能：将对象存入到容器；从容器中取出对象。其最核心的功能就是如何将对象存入到Spring中，再从Spring中获取对象的过程

将对象存放到容器中的好处:将对象存储在loC容器相当于将以后可能用的所有工具制作好都放到仓库中，需要的时候直接取就行了，用完再把它放回到仓库。而new对象的方式相当于，每次需要工具了，才现做，用完就扔掉了也不会保存，下次再用的时候还得重新做，这就是IoC容器和普通程序开发的区别。

4、DI（依赖注入）

在程序运行期间，动态地将某个对象引入到当前的机制（或行为）

从广义来说：IoC（设计思想）=DI（具体的实现技术），从不同的维度来描述同一问题

Spring的创建和使用

1、创建Spring项目

1.1、创建一个普通Maven项目

1.2、添加Spring框架支持

1.3、添加启动类和main方法

Maven项目导入jar和设置国内源的方法：

配置国内源

配置和检测 setting.xml

maven项目下载jar失败的解决方案：

没有配置国内源；

删除本地仓库的所有jar包，重写下载；

网络运营商访问国内源接口出现问题

2、存储Bean对象

2.1、创建Bean对象

public class User {public String exo(){return "baekhyun";}
}

2.2、将Bean对象存储到Spring当中

在resources下创建一个spring配置文件

将Bean对象配置到spring配置文件中

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xmlns:content="http://www.springframework.org/schema/context"xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd"><bean id="user" class="User"></bean>
</beans>

<bean id="user" class="User"></bean>
id中是bean对象名称 class中是对象本身：包名+类名

3、获取并使用Bean对象

3.1、先得到Spring上下文对象

或者

BeanFactory beanFactory=new XmlBeanFactory(new ClassPathResource("spring-config.xml"));

3.2、从Spring中取出Bean对象

User user= (User) context.getBean("user");

3.3、使用Bean

System.out.println(user.exo());

获取Bean的方式：

1、根据名称获取Bean

User user=（User）context.getBean（“user”）

2、根据Bean类型来获取Bean

User user=context.getBean（User.class）

3、根据Bean名称+Bean类型来获取Bean

User user=context.getBean（“user”,User.class）

ApplicationContext和BeanFactory

相同点：

1、都是可以得到Spring上下文对象；

2、都是来自Spring的顶级接口

不同点：

1、继承关系和功能方面来说: Spring容器有两个顶级的接口: BeanFactory和ApplicationContext。ApplicationContext 属于BeanFactory的子类，其中BeanFactory提供了基础的访问Bean的能力。ApplicationContext除了继承了BeanFactory 的所有功能之外，它还包含更多的功能，如国际化支持、资源访问、事件传播等。
2、从性能方面来说: ApplicationContext 是一次性加载并初始化所有的Bean对象，而BeanFactory 是需要哪个Bean才去加载Bean对象，因此更加轻量。

Spring更简单的读取和存储对象

1、存储Bean对象

1.1、配置扫描路径

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xmlns:content="http://www.springframework.org/schema/context"xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd"><content:component-scan base-package="com.demo.component"></content:component-scan><bean id="user" class="User"></bean>
</beans>

1.2、添加注解存储Bean对象

类注解：@Controller（控制器）、@Service（服务）、@Repository（仓库）、@Component（组件）、@Configuration（配置）

方法注解：@Bean（将当前修饰方法的方法对象存储到Spring当中）

方式一：类注解

1.2.1、@Controller（控制器存储）

@Controller
public class ArticleController {public String sayHi(){return "hello,controller";}
}

        ArticleController articleController=context.getBean("articleController",ArticleController.class);System.out.println(articleController.sayHi());

1.2.2、@Component（组件）

@Component
public class UserComponent {public String sayHi(){return "hi,@component";}
}

        UserComponent userComponent=context.getBean("userComponent",UserComponent.class);System.out.println(userComponent.sayHi());

项目中没有目录，所有的类都写在Java根路径下

<content:component-scan base-package="**"></content:component-scan>

1.2.3、@Service（服务）

@Service
public class ArticleController {public String sayHi(){return "hello,controller";}
}

1.2.4、@Repository（仓库）

@Repository
public class ArticleController {public String sayHi(){return "hello,controller";}
}

1.2.5、@Configuration（配置）

@Configuration
public class ArticleController {public String sayHi(){return "hello,controller";}
}

五大类注解用途：

1、@Controller（控制器）：归属于业务逻辑层，用来控制用户的行为，它用来检查用户参数的有效性

2、@Service（服务）：归属于服务层，调用持久化类实现相应的功能（不直接和数据库交互，类似于控制中心）

3、@Repository（仓库）：归属于持久层，是直接和数据库进行交互的。通常每一个表都会对应一个@Repository

4、@Configuration（配置）：归属于配置层，是用来配置当前项目的一些信息

4、@Component（组件）：归属于公共工具类，提供某些公共方法

调用流程如下：

方式二：方法注解

将返回的对象存储到Spring当中

注意事项：@Bean一定要配合五大类注解

public class Student {private int id;private String name;private int age;@Overridepublic String toString() {return "Student{" +"id=" + id +", name='" + name + '\'' +", age=" + age +'}';}public int getId() {return id;}public void setId(int id) {this.id = id;}public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}
}

@Component
public class StudentBeans {@Beanpublic Student student(){Student stu=new Student();stu.setId(04);stu.setName("baekhyun");stu.setAge(30);return stu;}
}

        Student student=context.getBean("student",Student.class);System.out.println(student);

或

@Component
public class StudentBeans {@Bean(name = {"s1","s2"})public Student student(){Student stu=new Student();stu.setId(04);stu.setName("baekhyun");stu.setAge(30);return stu;}
}

        Student student=context.getBean("s1",Student.class);System.out.println(student);

当给@Bean设置了name属性之后，使用原方法名就不能获取到对象了，只能使用设置的名称才能获取

2、获取Bean对象

获取bean对象的过程也叫做对象装配，是把对象取出来放到某个类中，其也叫做对象注入

2.1、属性注入

@Autowired

@Controller
public class StudentController {//1、使用属性注入获取bean@Autowiredprivate StudentService studentService;public void sayHi(){//调用service方法studentService.sayHi();}
}

@Service
public class StudentService {public void sayHi(){//System.out.println("hi,service");}
}

        StudentController sc=context.getBean("studentController",StudentController.class);sc.sayHi();

优点：实现简单

缺点：不能注入不可变（final）对象

只能适用于IoC容器

针对对象是类，容易违背单一设计原则

2.2、构造方法注入

    //3、构造方法注入private StudentService studentService;@Autowiredpublic StudentController(StudentService studentService){this.studentService=studentService;}

如果当前类中只有一个构造方法，可以省略@Autowired

优点：可以注入不可变对象；

    //3、构造方法注入private final StudentService studentService;public StudentController(StudentService studentService){this.studentService=studentService;}

注入对象不会被修改（原因：加了final修饰符；构造方法是随着类加载只执行一次的，不像set有可能执行多次被修改的风险）；

注入对象会被完全初始化；

通用性更好

缺点：没有属性注入实现简单

2.3、Setter注入

    //2、set注入private StudentService studentService;@Autowiredpublic void setStudentService(StudentService studentService){this.studentService=studentService;}

优点：更加符合单一设计原则（针对对象方法级别）

缺点：不能注入不可变对象

注入的对象可被修改（set方法是普通set方法，可以被重复调用，在被调用时就存在修改的风险）

2.4、使用@Resource（另一种注入方法）实现

    @Resourceprivate StudentService studentService;

@Resource和@Autowired

相同点：都是用来实现依赖注入的

不同点：

1、功能支持不同：@Autowired支持属性注入、setter注入、构造方法注入；@Resource支持属性注入和setter注入，但不支持构造方法注入

2、出身不同：@Autowired来自Spring框架；@Resource来自于JDK

3、参数支持不同：@Autowired只支持required参数；@Resource支持更多的参数设置

Bean作用域和生命周期

1、Bean作用域定义

Bean在整个Spring框架（项目）中的某种行为模式

1.1、singleton（单例作用域）

描述:该作用域下的Bean在loC容器中只存在一个实例:获取Bean(即通过applicationContext.getBean等方法获取)及装配Bean(即通过@Autowired注入)都是同一个对象

场景:通常无状态的Bean使用该作用域。无状态表示Bean对象的属性状态不需要更新

备注:Spring默认选择该作用域

@Controller
public class UserController {@Autowiredprivate User user1;public void getUser(){System.out.println("user1:"+user1);User u=user1;u.setName("边伯贤");System.out.println("u:"+u);}
}

@Controller
public class UserAdviceController {@Resourceprivate User user1;public void getUser(){System.out.println("user1:"+user1);}
}

@Component
public class UserBeans {@Beanpublic User user1(){User user=new User();user.setId(4);user.setName("baekhyun");user.setPassword("30");return user;}
}

        UserController userController=context.getBean("userController",UserController.class);userController.getUser();UserAdviceController userAdviceController=context.getBean("userAdviceController",UserAdviceController.class);userAdviceController.getUser();

1.2、prototype（原型作用域/多例作用域）

描述:每次对该作用域下的Bean的请求都会创建新的实例:获取Bean(即通过applicationContext.getBean等方法获取)及装配Bean(即通过@Autowired注入)都是新的对象实例

场景:通常有状态的Bean使用该作用域

1.3、request（请求作用域）

描述：每次http请求会创建新的Bean实例，类似于prototype

场景：一次http的请求和响应的共享Bean

备注：限定SpringMVC中使用

1.4、session（回话作用域）

描述：在一个http session中，定义一个Bean实例

场景：用户回话的共享Bean，比如：记录一个用户的登陆信息

备注：限定SpringMVC中使用

1.5、applicatioon（全局作用域）

描述：在一个http servlet Context中，定义一个Bean实例

场景：Web应用的上下文信息，比如：记录一个应用的共享信息

备注：限定SpringMVC中使用

singleton（单例作用域）和application（全局作用域）：

singleton是Spring Core的作用域，application是Spring Web中的作用域；

singleton作用于IoC的容器，application作用于Servlet容器

1.6、设置作用域

通过使用@Scope来设置Bean的作用域

直接设置值：@Scope("prototype")

全局变量的方式设置：@Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)

2、Spring执行流程和Bean的生命周期

2.1、Spring执行流程

a.启动容器（启动项目）；

b.读取配置文件，初始化（使用xml直接注册bean；配置bean根路径）；

c.将bean存储到spring中，通过类注解进行扫描和装配；

d.将spring从注解中读取出来，装配到相应的类

2.2、Bean生命周期

a.实例化Bean（为Bean分配内存空间）

b.设置属性（Bean的注入和装配）

c.Bean初始化

d.使用Bean

e.销毁Bean

@Component
public class BeanLifeComponent implements BeanNameAware {@Overridepublic void setBeanName(String s) {System.out.println("执行了通知");}@PostConstructpublic void postConstruct(){System.out.println("执行了@PostConstruct");}public void init(){System.out.println("执行了init-method方法");}@PreDestroypublic void PreDestory(){System.out.println("执行了销毁方法");}
}

public class App2 {public static void main(String[] args) {ClassPathXmlApplicationContext context=new ClassPathXmlApplicationContext("spring-config.xml");BeanLifeComponent beanLifeComponent=context.getBean("beanLifeComponent",BeanLifeComponent.class);System.out.println("使用Bean");//销毁Beancontext.destroy();}
}

案例：如何实现A->B->C

@Component
public class AComponent {@Autowiredprivate BComponent component;@PostConstructpublic void postConstruct(){System.out.println("执行了A对象的postConstruct方法");}
}

@Component
public class BComponent {@Autowiredprivate CComponent component;@PostConstructpublic void postConstruct(){System.out.println("执行了B对象的postConstruct方法");}
}

@Component
public class CComponent {@PostConstructpublic void postConstruct(){System.out.println("执行了C对象的postConstruct方法");}
}

public class App3 {public static void main(String[] args) {ApplicationContext context=new ClassPathXmlApplicationContext("spring-config.xml");AComponent aComponent=context.getBean("AComponent",AComponent.class);}
}