Spring入门：什么是spring?

最新推荐文章于 2022-05-10 08:48:52 发布

不许人间有白头

最新推荐文章于 2022-05-10 08:48:52 发布

阅读量298

点赞数

分类专栏： Spring 文章标签： spring java ioc

本文链接：https://blog.csdn.net/nnnnnnnnnnii/article/details/107456031

版权

Spring 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

1.什么是spirng？

Spring框架是一个开放源代码的J2EE应用程序框架，是针对bean的生命周期进行管理的轻量级容器。spring解决了开发者在J2EE开发中遇到的许多常见的问题，提供了功能强大IOC ，AOP 及 Web MVC等功能

1.spring的优点

1.方便解耦，简化开发
通过Spring 提供的IOC容器，我们可以将对象之间的雨来关系交给Spring进行控制，避免硬编码所造成的的过渡程序耦合，有了Spring, 用户不必再为了单实例模式类，属性文件解析等这些很底层的需求编写代码，可以更专注于上层的应用。
2.AOP编程的支持
通过Spring 提供的AOP功能。方便进行面向切面的编程，许多不容易用传统OOP实现的功能可以通过AOP轻松应付

1.3 Spring-framework下载
docs 文件为说明文档
libs 为依赖jar包
schema 为spring约束

2.Spring核心容器

Spring容器会负责控制程序之间的关系，而不是由程序代码直接控制。Spring为我们提供了两种核心器，分别为BeanFactory 和 ApplicationContext
1.BeanFactory
创建BeanFactory实例时，需要体统Spring所管理容器的详细配置信息，这些信息通常采用xml文件形式来管理，其加载配置信息的语法如下：

BeanFactory beanFactory = new xmlBeanFactory(new FileSystemResource("F:/applicationContext.xml"));

ApplicationContext
ApplicationContext是BeanFactory的子接口，是另一种常用的Spring核心容器，它由org.springframework.context.ApplicationContext接口定义，不仅包含了BeanFactory的所有功能，还添加了对国际化、资源访问、事件传播等方面的支持。创建ApplicationContext接口实例，通常采用
两种方法。
1.通过ClassPathXmlApplicationContext创建

ApplicationContext applicationContext = new ClassPathXmlApplicationContext(String configLocation);

 ApplicationContext applicationContext = new ClassPathXmlApplicationContext("classpath:bean1/bean.xml");
        Student student = (Student) applicationContext.getBean("haha");
        System.out.println("Student:"+student);

ClassPathXmlApplicationContext 会从类路径classPath中寻找制定的XML配置文件，找到并装在完成ApplicationContext的实例化工作

2.通过FileSystemXmlApplicationContext创建

ApplicationContext applicationContext = new FileSystemApplicationContext(Sting configLocation);

FileSystemXmlApplicationContext
会从指定的文件系统（绝对路径）中寻找指定的XML配置文件，找到并装在完成ApplicationContext的实例化工作。

3.获取Bean实例

创建Spirng容器后，就可以获取Spirng容器中的Bean,Spirng获取Bean的实例通常采用以下两种方法。

Object getBean(Sting name);
根据容器中Bean的id 或那么来获取指定的Bean , 获取之后需要进行强制类型转换。

Student student = (Student) applicationContext.getBean("haha");
 StudentService studentService1 = applicationContext.getBean(StudentService.class);

T getBean（Class requiredType）
根据类的类型来获取Bean的实例，由此方法为泛型方法，因此在获取Bean之后不需要进行强制类型转换

 StudentService studentService = (StudentService) applicationContext.getBean("studentService");

3.spring入门程序

1.创建maven工程，并在pom.xnl中引入以下依赖

<properties>
<!--在当前pom 或者父类pom 中声明属性 -->
<spirng.version>5.0.16.RELEASE</spirng.version>
</properties>
<dependencies>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>${spirng.version}</version>
</dependency>
</dependencies>

2.创建配置文件application.xml

<?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">
<!-- 声明一个 id 为student的 实例 -->
<bean id="student" class="com.wgz.spring.entity.Student">
<property name="name" value="xiaoming"/>
<property name="age" value="18"/>
</bean>
</beans>

3.测试

public class Test {
public static void main(String[] args) {
// 获取容器方式1
// BeanFactory beanFactory = new XmlBeanFactory(new
FileSystemResource("C:\\Users\\Admin\\Desktop\\假期
\\spring\\spring\\spring01\\springdemo\\src\\main\\resources\\application.xml"))
;
// Student student = beanFactory.getBean(Student.class);
// System.out.println("student:"+student);
// 获取容器方式2
// classpath: 加不加都可以
// ApplicationContext applicationContext = new
ClassPathXmlApplicationContext("classpath:application.xml");
// 获取容器方式3
ApplicationContext applicationContext = new
FileSystemXmlApplicationContext("C:\\Users\\Admin\\Desktop\\假期
\\spring\\spring\\spring01\\springdemo\\src\\main\\resources\\application.xml");
// Student student = applicationContext.getBean(Student.class);
Student student = (Student) applicationContext.getBean("student");
System.out.println("student:"+student);
}
}

4.控制反转&依赖注入

控制反转

控制反转，IOC。在使用Spring框架之后，对象的实例不再由调用者来创建，而是由Spring容器来创
建，Spring容器会负责控制程序之间的关系，而不是由调用者的程序代码直接控制。这样，控制权由应
用代码转移到了Spring容器，控制权发生了反转，这就是控制反转。

依赖注入

DI的全称是Dependency Injection，中文称之为依赖注入
从Spring容器的角度来看，Spring容器负责将被依赖对象赋值给调用者的成员变量，这相当于为调用者
注入了它依赖的实例，这就是Spring的依赖注入。

示例

1.分别创建Student对应的Dao,Service实现类

2.创建配置文件

<?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">
<!-- 声明一个 id 为studentDao的 实例 -->
<bean id="studentDao" class="com.wgz.spring.dao.impl.StudentDaoImpl">
</bean>
<!-- 声明一个 id 为studentService的 实例,并将id为 studentDao的实例注入给
StudentServiceImpl-->
<bean id="studentService" class="com.wgz.spring.service.StudentServiceImpl">
<property name="studentDao" ref="studentDao"></property>
</bean>
</beans>

3.测试

public class Test2 {
public static void main(String[] args) {
ApplicationContext applicationContext = new
ClassPathXmlApplicationContext("classpath:application.xml");
StudentService studentService =
applicationContext.getBean(StudentService.class);
Student student = studentService.findStudentById(10);
System.out.println("student:"+student);
}
}

5.Bean的配置（BeanFactory 的意思就是只能获取Bean对象，而不能生成Bean对象。生成Bean对象的的是FactoryBean）

1.什么是Bean?
如果把Spring看桌一个大型工厂，则Spirng容器中的Bean就是该工厂的产品。要想使用这个工厂生产和管理Bean,就需要在配置文件中告诉它需要哪些Bean,以及需要使用何种方式将这些Bean装配到一起。
2.Bean的属性
Bean的配置使用到了xml配置，xml配置文件中的根元素中包含了很多个子元素，每一个子元素定义了一个Bean,并描述了该Bean如何被装配到Spirng容器中，关于元素的常用属性如下表所示：
在这里插入图片描述

注意：“id必须是Bean中惟一的，而name可以有很多个”

3.bean的实例化（实例工厂是连接外部来用的）

在Spirng中，想要使用容器中的Bean,也需要实例化Bean。实例化Bean有三种方式，分别为构造器实例化，静态工厂实例化，和实例工厂方式实例化（其中最常用的是构造器实例化）。
构造器实例化：
这里不展示，因为直接在XML中给Bean里边的属性赋值就行

静态工厂方式实例化

1.创建对应的静态实例化
1.factory.StaticFactory

public class StaticFactory {
    public static Student creatStudent(){
        Student student = new Student();
        // 通过数据获取最新的数据 id name 获取 在set 设置值

        System.out.println("去数据查询数据");
        // 假装取数据数据得到数据
        String name = "小薇";
        int id = 2;

        student.setId(id);
        student.setName(name);

        return student;

    }
}

2.factory.staticFactory.xml

<?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:context="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="student" name="haha" class="com.aaa.test.factory.staticdemo.StaticFactory" factory-method="creatStudent"></bean>


</beans>

3.factory.StaticFactoryTest

public class StaticFactoryTest {
    public static void main(String[] args) {
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("classpath:factory/staticFactory.xml");


        // 更具name 进行获取
        Student student = (Student) applicationContext.getBean("student");

        System.out.println("student:"+student);

    }
}

4.entity.Student

package com.aaa.entity;

/**
 * ClassName:Student
 * Package:com.aaa.entity
 * Description:
 *
 * @date:2020/7/16 19:41
 * @author:lee907463383@qq.com
 */
public class Student {
    private  int id;
    private  String name;
    private  int age;
    private  int height;
    private  String sex;
    public void init(){
        System.out.println("Student 初始化");
    }
    public void destroy(){
        System.out.println("Student 销毁");
    }

    @Override
    public String toString() {
        return "Student{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", age=" + age +
                ", height=" + height +
                ", sex='" + sex + '\'' +
                '}';
    }

    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;
    }

    public int getHeight() {
        return height;
    }

    public void setHeight(int height) {
        this.height = height;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }
}

实例工厂方式实例化

1.创建实例工厂 factory.NormalFactory

public class NormalFactory {
   public Student creatStudent(){
        Student student = new Student();
        // 通过数据获取最新的数据 id name 获取 在set 设置值

        System.out.println("去数据查询数据");
        // 假装取数据数据得到数据
        String name = "小薇";
        int id = 2;

        student.setId(id);
        student.setName(name);

        return student;

    }
}

2.factory/normalFactory.xml

<?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:context="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="normalFactory" class="com.aaa.test.factory.normaldemo.NormalFactory"></bean>

    <!-- 当初始化bean 时数据如果时动态的，选哟通过网络或者数据获取，可以通过静态工厂,实例工厂 创建对象
             目的能够让容器更加灵活的的创建bean

             factory-bean="normalFactory"  指向实例工厂

             factory-method="createStudent" 执行创建bean的方法
          -->
   <bean id="student" name="haha" factory-bean="normalFactory" factory-method="creatStudent"></bean>

</beans>

3.com/aaa/test/factory/normaldemo/NormalFactoryTest.java

public class NormalFactoryTest {
    public static void main(String[] args) {

        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("classpath:factory/normalFactory.xml");


        // 更具name 进行获取
        Student student = (Student) applicationContext.getBean("student");

        System.out.println("student:"+student);


    }

4.bean的做用域

bean的作用域有7种，最常用的有单例和原型

在这里插入图片描述 singleton

singleton是Spring容器默认的作用域，当Bean的作用域为singleton时，Spring容器就只会存在一个共
享的Bean实例。singleton作用域对于无会话状态的Bean（如Dao 组件、Service组件）来说，是最理
想的选择。

1.xml配置

<?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">
<!-- 声明一个 id 为student的 实例 -->
<bean id="student1" class="com.wgz.spring.entity.Student" scope="singleton"
>
</bean>
<bean id="student2" class="com.wgz.spring.entity.Student" scope="prototype">
</bean>
</beans>

2.测试

public class ScopeTest {
public static void main(String[] args) {
ApplicationContext applicationContext = new
ClassPathXmlApplicationContext("classpath:scopebean.xml");
Student student1_a = (Student) applicationContext.getBean("student1");
Student student1_b = (Student) applicationContext.getBean("student1");
// 单例的作用域对象得到 只有
System.out.println("student1_a == student1_b："+
(student1_a==student1_b));
// 原型的作用域 得到的对象 有多个
Student student2_a = (Student) applicationContext.getBean("student2");
Student student2_b = (Student) applicationContext.getBean("student2");
System.out.println("student2_a == student2_b："+
(student2_a==student2_b));
}
}

5.bean的声明周期

**Spring容器可以管理Bean部分作用域的生命周期。有关说明具体如下
**

singleton

Spring容器可以管理singleton作用域的Bean的生命周期，在此作用域下，Spring能够精确的知道该
Bean何时被创建，何时初始化完成，以及何时被销毁。

prototype

prototype作用域的Bean，Spring只负责创建，当容器创建了Bean实例后，Bean的实例就交给客户端
代码来管理，Spring容器将不再跟踪其生命周期。

示例：

1.在Student增加声明周期相关的方法

/**
* 初始化方法
*/
public void init(){
System.out.println("对象初始化");
}
/**
* 销毁方法
*/
public void destroy(){
System.out.println("对象销毁了");
}

2.创建lifebean.xml，设置对应的方法

<?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">
<!-- 声明一个 id 为student的 实例 -->
<bean id="student1" class="com.wgz.spring.entity.Student" scope="singleton"
init-method="init" destroy-method="destroy">
</bean>
<bean id="student2" class="com.wgz.spring.entity.Student" scope="prototype"
init-method="init" destroy-method="destroy">
</bean>
</beans>

3.测试

import com.wgz.spring.entity.Student;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class LifeTest {
public static void main(String[] args) {
ClassPathXmlApplicationContext applicationContext = new
ClassPathXmlApplicationContext("lifebean.xml");
Student student1_a = (Student) applicationContext.getBean("student1");
// 原型的作用域
Student student2_a = (Student) applicationContext.getBean("student2");
applicationContext.destroy();
}
}

6.什么是Bean的装配？

** Bean的装配可以理解为依赖关系注入，Bean的装配方式即Bean依赖注入的方式。Spring容器支持多
种形式的Bean的装配方式，如基于XML的装配、基于注解（Annotation）的装配和自动装配（其中最
常用的是基于注解的装配）
**

1.基于XML的装配（分为两种）

- 设值注入

使用setter方法注入，必备条件：Bean类必须有一个无参构造方法，Bean类必须为属性提供setter方
法
xml配置

<bean id="student1" class="com.wgz.spring.entity.Student">
<property name="name" value="xiaoming"/>
<property name="age" value="18"/>
<property name="id" value="10"/>
<property name="sex" value="F"></property>
<property name="courseList" >
<list>
<value>"语文"</value>
<value>"数学"</value>
</list>
</property>
</bean>

- 构造方法注入

对应构造方法的每一参数，index为下标，从0开始

<bean id="student2" class="com.wgz.spring.entity.Student">
<constructor-arg index="0" value="10"></constructor-arg>
<constructor-arg index="1" value="xiaoming"></constructor-arg>
<constructor-arg index="2" value="18"></constructor-arg>
<constructor-arg index="3" value="F"></constructor-arg>
<constructor-arg index="4">
<list>
<value>"语文"</value>
<value>"数学"</value>
</list>
</constructor-arg>
</bean>

2.基于Annotation的装配

好处：来源:

基于XML的装配可能会导致XML配置文件过于臃肿，给后续的维护和升级带来一定的困难。为此，
Spring提供了对Annotation（注解）技术的全面支持。

注入的注解:有三种 1.@Autowired 2.@Qualifier3.@Resource

@Autowired：用于对Bean的属性变量、属性的setter方法及构造方法进行标注，配合对应的注解处理
器完成Bean的自动配置工作。
@Qualifier：与@Autowired注解配合使用，会将默认的按Bean类型装配修改为按Bean的实例名称装
配，Bean的实例名称由@Qualifier注解的参数指定。
@Resource：其作用与Autowired一样。@Resource中有两个重要属性：name和type。Spring将
name属性解析为Bean实例名称，type属性解析为Bean实例类型。

// @Autowired // 根据类型进行注入若有，多个类型的实例，需要配合
@Qualifier("studentDaoImpl2")
// @Qualifier("studentDaoImpl2")
@Resource() // 默认按照注解的字段名称进行装配， 若没有找到根据类型装配，如果对应类型的
实例有多个需要限定
private StudentDao studentDao ;

生成实例的注解: @Component @Repository @ Service @Controller
**@Component：**用于描述Spring中的Bean，它是一个泛化的概念，仅仅表示一个组件。
@Repository：用于将数据访问层（DAO）的类标识为Spring中的Bean 。
@Service:用于将业务层（Service）的类标识为Spring中的Bean。
@Controller：用于将控制层（Controller）的类标识为Spring中的Bean 。

1.半自动注解装配 annotation-config

开启注解处理器 @Autowired @ Resource 、@ PostConstruct、@ PreDestroy 相关注解注入生效

<?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:context="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">

    <!-- 激活 半自动注入的注解  @Autowired  @Qualifier @Resources   -->
    <context:annotation-config></context:annotation-config>


    <bean id="studentService" class="com.aaa.qy114.service.impl.StudentServiceImpl">
    </bean>


    <bean id="studentDao11111" class="com.aaa.qy114.dao.impl.StudentDaoImpl"></bean>


    <bean id="studentDao2" class="com.aaa.qy114.dao.impl.StudentDaoImpl"></bean>

</beans>

2.自动注解 context:component-scan
**扫描当前包下面的注解@Component @Controller @Service @Repository，生成实例，并装配
@Autowired @Resource
**

<?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:context="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">

    <!--
        扫描 base-package 下面所有 注解 @Component @Service @Controller @Repository 的类生成 对应的实例

      并且 激活 自动注入的注解  @Autowired  @Qualifier @Resources   -->
    <context:component-scan base-package="com.aaa"></context:component-scan>

</beans>

总结：

** context:component-scan 具有annotation-config的功能，并且能够生成实例**

3.基于xml的自动装配基本不用

所谓自动装配，就是将一个Bean自动的注入到到其他Bean的Property中。 Spring的元素中包含一个
autowire属性，我们可以通过设置autowire的属性值来自动装配Bean。autowire属性有5个值，其值及
说明下表所示：

在这里插入图片描述

<?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">
<!-- 声明一个 id 为studentDao的 实例 -->
<bean id="studentDao" class="com.wgz.spring.dao.impl.StudentDaoImpl">
</bean>
<!--
autowire="byType" 此时容器中只能有一个对象
autowire="byName" 使用 studentService内部的变量作为id 去获取
autowire="constructor" 必须有构造函数
-->
<bean id="studentService" class="com.wgz.spring.service.StudentServiceImpl"
autowire="constructor">
</bean>
</beans>

不许人间有白头

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Spring入门：什么是spring?

1.什么是spirng？Spring框架是一个开放源代码的J2EE应用程序框架，是针对bean的生命周期进行管理的轻量级容器。spring解决了开发者在J2EE开发中遇到的许多常见的问题，提供了功能强大IOC ，AOP 及 Web MVC等功能1.spring的优点1.方便解耦，简化开发通过Spring 提供的IOC容器，我们可以将对象之间的雨来关系交给Spring进行控制，避免硬编码所造成的的过渡程序耦合，有了Spring, 用户不必再为了单实例模式类，属性文件解析等这些很底层的需求编写代码
复制链接

扫一扫