Spring基础1

我哪会这个啊

已于 2022-01-25 10:05:29 修改

阅读量176

点赞数

分类专栏： spring 文章标签： spring

于 2021-02-25 16:55:23 首次发布

本文链接：https://blog.csdn.net/qq_45243783/article/details/114061818

版权

spring 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

IOC创建对象的方式
定义一个实体类

public class Hello {
      private String str;

      public Hello(String str){
          this.str = str;
      }
    public String getStr() {
        return str;
    }
    public void setStr(String str) {
        this.str = str;
    }
    @Override
    public String toString() {
        return "Hello{" +
                "str='" + str + '\'' +
                '}';
    }
}

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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd">

<!--使用Spring来创建对象，/在Spring这些都称为Bean

       类型  变量名=new 类型（）；
          Hello hello=new Hello();

            id =变量名
             class =new 的对象
             property 相当于给对象中的属性设置一个值！
-->
<bean id="hello" class="com.cd.pojo.Hello">
    <property name="str" value="Spring"/>
</bean>

</beans>

2.假设我们要使用有参构造创建对象

下标赋值

<bean id="user" class="com.cd.pojo.User">
      <constructor-arg index="0" value="张三"/>
</bean>

类型

<bean id="user" class="com.cd.pojo.User">
           <constructor-arg type="java.lang.String" value="张三"/>
</bean>

参数名

<bean id="user" class="com.cd.pojo.User">
          <constructor-arg name="name" value="张三"/>
</bean>

测试代码

public class MyTest {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        User user = (User)context.getBean("user");
        user.show();
    }
}

总结： 在配置文件加载的时候，容器中管理的对象就已经初始化了！

Spring配置
别名：
在这里插入图片描述
Bean的配置

import
这个import,一般用于团队开发使用，他可以将多个配置文件，导入合并为一个。
假设，现在项目中有多个人开发，这三个人复制不同的类开发，不同的类需要注册在不同的bean中，我们可以利用import将所有的beans.xml合并为一个总的！

张三
李四
王五
applicationContext.xml

使用的时候，使用总的配置就可以了

依赖注入

1- 构造器注入
前面已经说过了

2 - Set注入(重点)

依赖注入：Set注入
依赖：bean对象的创建依赖于容器
注入：bean对象中所有的属性，由容器来注入！
测试环境搭建

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

@Override
public String toString() {
   return "Address{" +
           "address='" + address + '\'' +
           '}';
}

}

public class Student {
    private String name;
    private Address address;
    private String[] books;
    private List<String> hobbys;
    private Map<String,String> cars;
    private Set<String> games;
    private String wife;
    private Properties info;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Address getAddress() {
        return address;
    }
    public void setAddress(Address address) {
        this.address = address;
    }
    public String[] getBooks() {
        return books;
    }
    public void setBooks(String[] books) {
        this.books = books;
    }
    public List<String> getHobbys() {
        return hobbys;
    }
    public void setHobbys(List<String> hobbys) {
        this.hobbys = hobbys;
    }
    public Map<String, String> getCars() {
        return cars;
    }
    public void setCars(Map<String, String> cars) {
        this.cars = cars;
    }
    public Set<String> getGames() {
        return games;
    }
    public void setGames(Set<String> games) {
        this.games = games;
    }
    public String getWife() {
        return wife;
    }
    public void setWife(String wife) {
        this.wife = wife;
    }
    public Properties getInfo() {
        return info;
    }
    public void setInfo(Properties info) {
        this.info = info;
    }
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", address=" + address +
                ", books=" + Arrays.toString(books) +
                ", hobbys=" + hobbys +
                ", cars=" + cars +
                ", games=" + games +
                ", wife='" + wife + '\'' +
                ", info=" + info +
                '}';
    }
}

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"
       xmlns:p="http://www.springframework.org/schema/p"
       xmlns:c="http://www.springframework.org/schema/c"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd">

     <bean id="address" class="com.cd.pojo.Address">
         <property name="address" value="西安"/>
     </bean>
    <bean id="student" class="com.cd.pojo.Student">
        <!--第一种普通值注入    value-->
        <property name="name" value="秦疆"/>

        <!--第二种，bean注入  ref-->
        <property name="address" ref="address"/>

        <!--数组-->
        <property name="books" >
            <array>
                 <value>红楼梦</value>
                 <value>西游记</value>
                <value>水浒传</value>
                <value>三国演义</value>
            </array>
        </property>

        <!--List-->
          <property name="hobbys">
              <list>
                  <value>唱歌</value>
                  <value>跳舞</value>
                  <value>编程</value>
                  <value>篮球</value>
              </list>
          </property>


        <!--Map-->
           <property name="cars">
               <map>
                 <entry key="身份证" value="111111112233636"/>
                   <entry key="银行卡" value="42556644785956"/>
               </map>
           </property>

        <!--Set-->
         <property name="games">
             <set>
                 <value>LOL</value>
                 <value>NBA2KOnline</value>
                 <value>BOB</value>
             </set>
         </property>


           <!--null-->
     <property name="wife">
         <null/>
     </property>
        <!--Properties-->
      <property name="info">
          <props>
           <prop key="driver">20190525</prop>
              <prop key="url">localhost:3306</prop>
              <prop key="username">root</prop>
              <prop key="password">root</prop>
          </props>
      </property>
    </bean>
</beans>

测试代码：

public class MyTest {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        Student student =(Student) context.getBean("student");
        System.out.println(student.toString());
    }

拓展方式注入
我们可以使用p命名空间和c命名空间注入

public class User {
    private String name;
    private int age;
    public User() {
    }
    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }
    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 String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

<?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:p="http://www.springframework.org/schema/p"
       xmlns:c="http://www.springframework.org/schema/c"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd">


        <!--p命名空间注入，可以直接注入属性的值：property-->
      <bean id="user" class="com.cd.pojo.User" p:name="张三" p:age="18"/>

       <!--c命名空注入： 通过构造器注入： construct-args -->
          <bean id="user2" class="com.cd.pojo.User" c:age="18" c:name="张三" scope="singleton"/>
</beans>

测试代码：

@Test
    public void test2(){
        ApplicationContext context = new ClassPathXmlApplicationContext("userbeans.xml");
        User user = context.getBean("user", User.class);
        System.out.println(user);
    }

注意: p命名空间个c命名空间不能直接使用，需要导入xml约束！

 xmlns:p="http://www.springframework.org/schema/p"
 xmlns:c="http://www.springframework.org/schema/c"

bean的作用域
在这里插入图片描述
1.单例模式（Spring默认的机制）

 <bean id="user2" class="com.cd.pojo.User" c:age="18" c:name="小明" scope="singleton"/>

每次从容器中get的时候，都是同一个对象
2.原型模式：每次从容器中get的时候，都会产生一个新的对象！

<bean id="user2" class="com.cd.pojo.User" c:age="18" c:name="zhangsan" scope="prototype"/>

3其余的request,session,application这些个只能在web开发中使用到

**7.Bean的自动装配

自动装配是Spring满足bean依赖的一种方式
Spring会在上下文中自动寻找，并自动给bean装配属性

在Spring中有3种装配的方式

在xml中显示的装配
在java中显示装配
隐式的自动装配bean[重要]

测试环境搭建：一个人有两个宠物

public class Cat {
    public void shout(){
        System.out.println("miao ~");
    }
}

public class Dog {
      public void shout(){
          System.out.println("wang~");
      }
}

public class People {

     //如果显示的定义了Autowired的required属性为false,说明这个对象可以为null,否则不允许为空
      @Autowired
      @Qualifier(value="cat1")
    private Cat cat;

       @Autowired
       @Qualifier(value="dog1")
    private Dog dog;
    private String name;
    public Cat getCat() {
        return cat;
    }
    public void setCat(Cat cat) {
        this.cat = cat;
    }
    public Dog getDog() {
        return dog;
    }
    public void setDog(Dog dog) {
        this.dog = dog;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    @Override
    public String toString() {
        return "People{" +
                "cat=" + cat +
                ", dog=" + dog +
                ", name='" + name + '\'' +
                '}';
    }
}

7.2 ByName自动装配
在这里插入图片描述
7.3 ByType自动装配

public class MyTest {
    @Test
    public void test1(){
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        People people = context.getBean("people", People.class);
          people.getDog().shout();
          people.getCat().shout();
    }
}

小结：

byName的时候,需要保证所有的bean的id唯一，并且这个bean需要和自动注入的属性的set方法的值一致
bytype的时候，需要保证所有bean的class唯一，并且这个bean需要和自动注入属性的类型一致

7.4使用注解实现自动装配
jdk1.5支持注解，Spring2.5就支持注解了！
要想使用注解须知：
1.导入约束: context约束
2.配置注解支持：context:annotation-config/

<?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
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        https://www.springframework.org/schema/context/spring-context.xsd">
      
      <!--开启注解支持-->
    <context:annotation-config/>
    
</beans>

Autowire
直接在属性上面使用即可，也可以在set方法上使用！
使用Autowire我们可以不用编写Set方法了，前提是你这个自动装配的属性在IOC（Spring）容器中存在，且符合名字byname(先找byType,然后再找byname)

科普：

在这里插入图片描述
如果@Autowire自动装配的环境比较复杂，自动装配无法通过一个注解【@Autowire】完成的时候，我们可以使用@Qualifier(value=“xxx”)去配置@Autowire的使用，指定一个唯一的bean 对象注入！

public class People {

     //如果显示的定义了Autowired的required属性为false,说明这个对象可以为null,否则不允许为空
      @Autowired
      @Qualifier(value="cat1")
    private Cat cat;

       @Autowired
       @Qualifier(value="dog1")
    private Dog dog;
    private String name;

    public Cat getCat() {
        return cat;
    }

@Resource注解
在这里插入图片描述
小结
@Autowire和@Resource之间的区别：

都是用来自动装配的，都可以放在属性字段上面
@Autowire通过byType的方式实现，而且必须要求这个对象存在！【常用】
@Resource默认通过byname的方式实现，如果找不到名字，则通过byType实现，如果两个都找不到的情况下，就会报错【常用】
执行顺序不同：@Autowire通过byType的方式实现，@Resource默认通过byname的方式实现

8.使用注解开发
在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
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        https://www.springframework.org/schema/context/spring-context.xsd">

    <!--指定要扫描的包，这个包下的注解就会生效-->
        <context:component-scan base-package="com.cd"/>
      
         <!--提供注解支持-->
    <context:annotation-config/>

</beans>

2.属性如何注入
在这里插入图片描述
3.衍生的注解
@Component有几个衍生的注解，我们在web开发中，会按照mvc三层架构分层

dao @Repository
service @Service
controller @Controller

这四个注解功能都是一样的，都是代表将某个类注册到Spring中，装配Bean
4.自动装配
在这里插入图片描述

//等价于 <bean id="user" class="com.cd.pojo.User"/>
       //@Component 意思就是组建的意思

@Component
public class User {
     //相当于 <property name="name"  value="雨神"/>
        @Value("雨神")
    public String name;
}

6.小结
xml与注解：

xml更加万能，适用于任何场合，维护简单方便
注解不是自己的类使用不了，维护相对复杂！

xml与注解最佳实践：

xml用来管理bean;
注解只用来完成属性的注入
我们在使用的过程中，只需要注意一个问题：必须让注解生效，就需要开启注解的支持

  <!--指定要扫描的包，这个包下的注解就会生效-->
        <context:component-scan base-package="com.cd"/>
        <context:annotation-config/>

使用java的方式配置Spring
我们现在要完全不使用Spring的xml配置了，全权交给java来做！
JavaConfig是Spring的一个子项目，在Spring4之后，他就成为了一个核心功能
在这里插入图片描述
实体类

配置文件

测试类

这种纯java的配置方式，在springboot中随处可见

我哪会这个啊

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Spring基础1

IOC创建对象的方式定义一个实体类public class Hello { private String str; public Hello(String str){ this.str = str; } public String getStr() { return str; } public void setStr(String str) { this.str = str; }
复制链接

扫一扫

专栏目录