Spring基础入门（狂神说笔记）

只想悄咪咪搞钱

已于 2022-02-26 11:26:05 修改

阅读量342

点赞数 1

文章标签： spring java 后端

于 2022-02-24 10:40:20 首次发布

本文链接：https://blog.csdn.net/zwt174309/article/details/123106488

版权

spring笔记

1.什么是spring

spring是一个轻量级的开源框架

2.spring的核心是啥

ioc和aop

控制反转和面向切面编程

将对象的创建权利交用户

1.控制反转的推导

1.创建一个实体类

public class User{
    private int age;
    private String name;
    get/set        
}

2.创建一个UserDao接口

public interface  UserDao{
    //获取用户信息
    public void getUser(){
    }
}

3.实现UserDao接口

public class UserDaoImp implements UserDao{
    public void getUser(){
        System.out.println("获取用户数据");
    }
}

4.创建一个service接口

public interface  UserService{
    public void getUser();
}

5.实现service接口

public class UserServiceImp implements UserService{
    private UserDao=new UserDaoImp();
    public void getUser(){
    UserDao.getUser
    }
}

以上就是没有使用控制反转的代码流程，再往里面添加多个数据库查询dao层的对象就会变得十分多，代码复用性差

6.往doa层添加多个实现类

添加MySql实现类

public class UserDaoMySqlImpl implements UserDao {
   @Override
   public void getUser() {
       System.out.println("MySql获取用户数据");
  }
   
}

添加Oracle实现类

public class UserDaoOracleImpl implements UserDao {
public void getUser() {
       System.out.println("Oracle获取用户数据");
  }
}

紧接着我们要去使用MySql的话 , 我们就需要去service实现类里面修改对应的实现

public class UserServiceImpl implements UserService {
   private UserDao userDao = new UserDaoMySqlImpl();
   @Override
   public void getUser() {
       userDao.getUser();
  }
}

那么我们要使用Oracle , 又需要去service实现类里面修改对应的实现 . 假设我们的这种需求非常大 , 这种方式就根本不适用了, 每次变动 , 都需要修改大量代码 . 这种设计的耦合性太高了, 牵一发而动全身 .

7.进行控制反转

将dao层的对象创建选择权交给用户

在dao层实现时留下一个set接口，

public UserServiceImp implements UserService{
    //将dao接口进行封装
    private UserDao userDao;
    //设置一个dao的set方法
    set方法
    public void getUser(){
	userDao.getUser();
}

8.进行测试

public class Test{
    UserService userService=new DaoServiceImp();
    userService.set(new UserDaoMySql);
    userService.getUser();
}

2.第一个Spring程序

导入spring依赖

<dependency>
   <groupId>org.springframework</groupId>
   <artifactId>spring-webmvc</artifactId>
   <version>5.1.10.RELEASE</version>
</dependency>

编写一个实体类

public class Hello {
   private String name;

   public String getName() {
       return name;
  }
   public void setName(String name) {
       this.name = name;
  }

   public void show(){
       System.out.println("Hello,"+ name );
  }
}

编写我们的spring文件

这里我们命名为beans.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">

   <!--bean就是java对象 , 由Spring创建和管理-->
   <bean id="hello" class="com.kuang.pojo.Hello">
       <property name="name" value="Spring"/>
   </bean>

</beans>

Hello 对象是谁创建的 ? hello 对象是由Spring创建的
Hello 对象的属性是怎么设置的 ? hello 对象的属性是由Spring容器设置的

这个过程就叫控制反转 :

控制 : 谁来控制对象的创建 , 传统应用程序的对象是由程序本身控制创建的 , 使用Spring后 , 对象是由Spring来创建的
反转 : 程序本身不创建对象 , 而变成被动的接收对象 .

依赖注入 : 就是利用set方法来进行注入的.

IOC是一种编程思想，由主动的编程变成被动的接收

3.ioc创建对象的方式

1.通过无参构造方法来创建

结果可以发现，在调用show方法之前，User对象已经通过无参构造初始化了！

2.通过有参构造方法来创建

结论：在配置文件加载的时候。其中管理的对象都已经初始化了！

beans.xml 有三种方式编写

<!-- 第一种根据index参数下标设置 -->
<bean id="userT" class="com.kuang.pojo.UserT">
   <!-- index指构造方法 , 下标从0开始 -->
   <constructor-arg index="0" value="kuangshen2"/>
</bean>
<!-- 第二种根据参数名字设置 -->
<bean id="userT" class="com.kuang.pojo.UserT">
   <!-- name指参数名 -->
   <constructor-arg name="name" value="kuangshen2"/>
</bean>
<!-- 第三种根据参数类型设置 -->
<bean id="userT" class="com.kuang.pojo.UserT">
   <constructor-arg type="java.lang.String" value="kuangshen2"/>
</bean>

4.spring的配置

4.1别名

alias设置别名,为bean设置别名，可以设置多个别名

<!--设置别名：在获取Bean的时候可以使用别名获取-->
<alias name="userT" alias="userNew"/>

4.2Bean的配置

<!--bean就是java对象,由Spring创建和管理-->

<!--
   id 是bean的标识符,要唯一,如果没有配置id,name就是默认标识符
   如果配置id,又配置了name,那么name是别名
   name可以设置多个别名,可以用逗号,分号,空格隔开
   如果不配置id和name,可以根据applicationContext.getBean(.class)获取对象;

class是bean的全限定名=包名+类名
-->
<!--id,唯一标识符， class全限定名，包名+类名， name，别名而且比alias更高级，可以一对多-->
<bean id="hello" name="hello2 h2,h3;h4" class="com.kuang.pojo.Hello">
   <property name="name" value="Spring"/>
</bean>

4.3import

团队的合作通过import来实现

一般用于团队开发使用，它可以将多个配置文件，导入合并为一个

假设有三个程序员分别复制了不同的类去开发，不同的类需要注册到不同的bean中，此时可以利用import将所有的bean.xml合并成一个总的（applicationContext.xml)

<import resource="{path}/beans.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
        https://www.springframework.org/schema/beans/spring-beans.xsd">

    <import resource="beans.xml"/>
    <import resource="beans2.xml"/>
    <import resource="beans3.xml"/>
</beans>

5.依赖注入

什么是依赖注入

依赖注入分为，依赖和注入

依赖：指的是Bean对象创建依赖SpringIoc容器。Bean对象的依赖资源（初始化，数据的获取等等0）

注入：指的是Bean对象依赖的资源，由容器来设置和装配

6.构造注入

6.1Set的注入

要求被注入的对象必须要有set方法，如果属性是Boolean类型的，没有set方法，是is

Address类

 public class Address {
 
     private String address;
 
     public String getAddress() {
         return address;
    }
 
     public void setAddress(String address) {
         this.address = address;
    }
 }

6.4Bean的作用域

在Spring中，那些组成应用程序的主体及由Spring IoC容器所管理的对象，被称之为bean。简单地讲，bean就是由IoC容器初始化、装配及管理的对象 .

scope属性设置作用域

 <bean id="ServiceImpl" class="cn.csdn.service.ServiceImpl" scope="singleton">

7.Bean的自动装配

自动装配是使用spring满足bean依赖的一种方法
spring会在应用上下文中为某个bean寻找其依赖的bean。

Spring中bean有三种装配机制，分别是：
1. 在xml中显式配置；
2. 在java中显式配置；
3. 隐式的bean发现机制和自动装配。

Spring的自动装配需要从两个角度来实现，或者说是两个操作：

组件扫描(component scanning)：spring会自动发现应用上下文中所创建的bean；
自动装配(autowiring)：spring自动满足bean之间的依赖，也就是我们说的IoC/DI；

组件扫描和自动装配组合发挥巨大威力，使得显示的配置降低到最少。

7.1byName

autowire byName（按名称自动装配）

由于在手动配置xml过程中，常常发生字母缺漏和大小写等错误，而无法对其进行检查，使得开发效率降低。

采用自动装配将避免这些错误，并且使配置简单化。

按名称自动装配原理

当一个bean节点带有 autowire byName的属性时。

将查找其类中所有的set方法名，例如setCat，获得将set去掉并且首字母小写的字符串，即cat。
去spring容器中寻找是否有此字符串名称id的对象。
如果有，就取出注入；如果没有，就报空指针异常。

7.2byType

autowire Type（按类型自动装配）

使用autowire byType首先需要保证：同一类型的对象，在spring容器中唯一。如果不唯一，会报不唯一的异常。

7.3使用注解

前置准备

1.将spring配置文件引入到context文件头中

xmlns:context="http://www.springframework.org/schema/context"

http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd

2.开启属性注解支持

<context:annotation-config/>

@Autowired

该注解是按照类型自动装配的，并不支持id匹配

需要导入spring-apo的包

补充

@Autowire（required=false）说明：false，对象可以为null；ture，对象必须存对象，不能为null。

//如果允许对象为null，设置required = false,默认为true
@Autowired(required = false)
private Cat cat;

@Qualifier

修饰符;限定符;限定词;修饰词;限定语

@Autowired是根据类型自动装配的，加上@Qualifier则可以根据byName的方式自动装配
@Qualifier不能单独使用。

@Autowired
@Qualifier(value = "cat2")
private Cat cat;
@Autowired
@Qualifier(value = "dog2")
private Dog dog;

@Resource

@Resource如有指定的name属性，先按该属性进行byName方式查找装配；
其次再进行默认的byName方式进行装配；
如果以上都不成功，则按byType的方式自动装配。
都不成功，则报异常。

实体类

public class User {
   //如果允许对象为null，设置required = false,默认为true
   @Resource(name = "cat2")
   private Cat cat;
   @Resource
   private Dog dog;
   private String str;
}

7.4总结

@Autowired与@Resource异同：

1、@Autowired与@Resource都可以用来装配bean。都可以写在字段上，或写在setter方法上。

2、@Autowired默认按类型装配（属于spring规范），默认情况下必须要求依赖对象必须存在，如果要允许null 值，可以设置它的required属性为false，如：@Autowired(required=false) ，如果我们想使用名称装配可以结合@Qualifier注解进行使用

3、@Resource（属于J2EE复返），默认按照名称进行装配，名称可以通过name属性进行指定。如果没有指定name属性，当注解写在字段上时，默认取字段名进行按照名称查找，如果注解写在setter方法上默认取属性名进行装配。当找不到与名称匹配的bean时才按照类型进行装配。但是需要注意的是，如果name属性一旦指定，就只会按照名称进行装配。

它们的作用相同都是用注解方式注入对象，但执行顺序不同。@Autowired先byType，@Resource先byName。

8.使用注解开发

8.1前置准备

在spring4之后，想要使用注解形式，必须得要引入aop的包

在这里插入图片描述

在配置文件当中，还得要引入一个context约束

<?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
       http://www.springframework.org/schema/context/spring-context.xsd">

</beans>

8.2Bean的实现

我们之前都是使用 bean 的标签进行bean注入，但是实际开发中，我们一般都会使用注解！

1.配置扫描哪些包下的注解

<!--指定注解扫描包-->
<context:component-scan base-package="com.kuang.pojo"/>

2.在指定包下编写类,Component

增加注解，Component,核心部分.括号内没用内容则表示将该类标记注册为一个Spring组件，放到容器中

@Component("user")
// 相当于配置文件中 <bean id="user" class="当前注解的类"/>
public class User {
   public String name = "秦疆";
}

8.3属性的注入

使用注解注入属性

1.@Value

可以不用提供set方法，直接在直接名上添加@value(“值”)

@Component("user")
// 相当于配置文件中 <bean id="user" class="当前注解的类"/>
public class User {
   @Value("秦疆")
   // 相当于配置文件中 <property name="name" value="秦疆"/>
   public String name;
}

2、如果提供了set方法，在set方法上添加@value(“值”);

@Component("user")
public class User {

   public String name;

   @Value("秦疆")
   public void setName(String name) {
       this.name = name;
  }
}

8.4衍生注解

我们这些注解，就是替代了在配置文件当中配置步骤而已！更加的方便快捷！

@Component三个衍生注解

为了更好的进行分层，Spring可以使用其它三个注解，功能一样，目前使用哪一个功能都一样。

@Controller：controller层
@Service：service层
@Repository：dao层

写上这些注解，就相当于将这个类交给Spring管理装配了！

8.5.自动装配注解

在Bean的自动装配已经讲过了，可以回顾！

8.6.作用域

@scope

singleton：默认的，Spring会采用单例模式创建这个对象。关闭工厂，所有的对象都会销毁。
prototype：多例模式。关闭工厂，所有的对象不会销毁。内部的垃圾回收机制会回收

@Controller("user")
@Scope("prototype")
public class User {
   @Value("秦疆")
   public String name;
}

8.7小结

xml可以适用于任何场景，结构清晰，方便维护

注解不是自己提供的类使用不了，开发简单方便

使用方法

xml和注解的整合开发

xml管理bean

注解完成属性注入

使用过程，可以不使用扫描，扫描是为了类上的注解

补充说明：注解完成属性注入，是作用于属性上的，不是类上的

<context:annotation-config/>

以上的作用

进行注解驱动的注入，从而使注解生效

用于激活那些已经在Spring容器中已经注册过bean的注解，也就是显示的向spring注册

如果不扫描包，就需要手动的配置bean

如果不加注解驱动，则注入的值为null.

9.基于java类进行的配置

JavaConfig 原来是 Spring 的一个子项目，它通过 Java 类的方式提供 Bean 的定义信息。

在 Spring4 的版本， JavaConfig 已正式成为 Spring4 的核心功能。

1.编写一个实体类

@Component  //将这个类标注为Spring的一个组件，放到容器中！
public class Dog {
   public String name = "dog";
}

2、新建一个config配置包，编写一个MyConfig配置类

@Configuration  //代表这是一个配置类
public class MyConfig {

   @Bean //通过方法注册一个bean，这里的返回值就Bean的类型，方法名就是bean的id！
   public Dog dog(){
       return new Dog();
  }

}

只想悄咪咪搞钱

关注

1
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
Spring基础入门（狂神说笔记）

spring笔记1.什么是springspring是一个轻量级的开源框架2.spring的核心是啥ioc和aop控制反装和面向切面编程将对象的创建权利交用户1.控制反转的推导1.创建一个实体类public class User{ private int age; private String name; get/set }2.创建一个UserDao接口public interface UserDao{ //获取用户信息 pub
复制链接

扫一扫