Spring学习第二课

1.HelloSpring

如何编写第一个Spring程序？

首先需要导入一个jar包：spring 需要导入commons-logging进行日志记录 . 我们利用maven , 他会自动下载对应的依赖项 .

在pom输入

1
2
3
4
5
<dependency>
   <groupId>org.springframework</groupId>
   <artifactId>spring-webmvc</artifactId>
   <version>5.1.10.RELEASE</version>
</dependency>

编写一个实体类：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class Hello {
    private String str;
    //用set方法进行依赖注入
    public void setStr(String str) {
        this.str = str;
    }
    public String getStr() {
        return str;
    }
    @Override
    public String toString() {
        return "Hello{" +
                "str='" + str + '\'' +
                '}';
    }
}

编写我们的spring文件 并且命名为beans.xml这一主要是使用spring创建java对象

1
2
3
4
5
6
7
8
9
10
<!--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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
<!--使用spring来创建对象 在spring中这些都叫bean其中id为创建的对象名，class为实体类的路径、property中name为实体类中对应的set方法参数-->
    <bean id="hello" class="pojo.Hello">
        <property name="str" value="Spring"/>
    </bean>
</beans>

测试

1
2
3
4
5
6
7
8
9
public class MyTest {
    public static void main(String[] args) {
        //解析beans.xml文件 , 生成管理相应的Bean对象
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        //getBean : 参数即为spring配置文件中bean的id .
        Hello hello = (Hello) context.getBean("hello");
        System.out.println(hello.toString());
    }
}

在这个过程中Hello的对象是由spring创建的，Hello属性是由spring容器设置的，这个过程叫做控制反转

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

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

2.Spring创建多个对象

在spring入门第一课中添加一个bean.xml文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
<?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 id="MysqlImpl" class="com.kuang.dao.impl.UserDaoMySqlImpl"/>
   <bean id="OracleImpl" class="com.kuang.dao.impl.UserDaoOracleImpl"/>

   <bean id="ServiceImpl" class="com.kuang.service.impl.UserServiceImpl">
       <!--注意: 这里的name并不是属性 , 而是set方法后面的那部分 , 首字母小写-->
       <!--引用另外一个bean , 不是用value 而是用 ref-->
       <property name="userDao" ref="OracleImpl"/>
   </bean>

</beans>

进行测试：

1
2
3
4
5
6
@Test
   public void test2(){
       ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
       UserServiceImpl serviceImpl = (UserServiceImpl) context.getBean("ServiceImpl");
       serviceImpl.getUser();
   }

这个部分的代码主要是在bean.xml中创建对象进行调用，这样如果要实行不同的操作，只需要在xml配置文件中进行修改，所谓的IOC就是对性有Spring来创建管理装配。

3.IOC创建对象方式

3.1通过无参构造方式创建

创建一个user.java实体类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public class User {

   private String name;

   public User() {
       System.out.println("user无参构造方法");
  }

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

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

}

bean.xml

1
2
3
4
5
6
7
8
9
10
11
<?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 id="user" class="com.kuang.pojo.User">
       <property name="name" value="JXsir"/>
   </bean>

</beans>

设置测试类

1
2
3
4
5
6
7
8
@Test
public void test(){
   ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
   //在执行getBean的时候, user已经创建好了 , 通过无参构造
   User user = (User) context.getBean("user");
   //调用对象的方法 .
   user.show();
}

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

3.2通过有参构造方式创建

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public class UserT {

   private String name;

   public UserT(String name) {
       this.name = name;
  }

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

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

}

bean.xml有三种书写方式：

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

测试类:

1
2
3
4
5
6
@Test
public void testT(){
   ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
   UserT user = (UserT) context.getBean("userT");
   user.show();
}

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

4.Spring配置

别名

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

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

bean.xml的配置

1
2
3
4
5
6
7
8
9
10
11
12
13
<!--bean就是java对象,由Spring创建和管理-->

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

class是bean的全限定名=包名+类名
-->
<bean id="hello" name="hello2 h2,h3;h4" class="com.kuang.pojo.Hello">
   <property name="name" value="Spring"/>
</bean>

import

团队的何战通过import来实现

1
<import resource="{path}/beans.xml"/>