Spring快速入门

Spring快速入门

Spring概述

Spring是分层的 Java SE/EE应用 full-stack 轻量级开源框架，以 IoC（Inverse Of Control：反转控制）和

AOP（Aspect Oriented Programming：面向切面编程）为内核。

• Ioc：控制封装（依赖注入），就是通过容器来控制程序之间的依赖关系，而并不像一般代码中，由程序代码直接操控。这就是所谓的控制反转即：（依赖）控制权由原来的代码中转到了外面的容器，控制权的转移，就说所谓的反转。由容器动态的将某种依赖关系注入到组件之中 。

---

案例：Spring程序的开发

1. 导入Spring开发的基本包坐标

      <dependency>
        <!--导入spring的context坐标，context依赖core、beans、expression-->
         <groupId>org.springframework</groupId>
         <artifactId>spring-context</artifactId>
         <version>5.0.5.RELEASE</version>
       </dependency
   
   

2. 编写Dao接口和实现类，这里就简单打印一句话

   //接口
   public interface UserDao {
       public void show();
   }
   //实现类
   public class UserDaolmpl implements UserDao {
       public void show() {
           System.out.println("run...Spring");
       }
   }
   

3. 创建SpringMVC核心配置文件：在类路径“resources”下创建applicationContext.xml配置文件

• 在xml配置文件中的配置如下：

   <bean id="userDao" class="com.itheima.dao.UserDaolmpl"></bean>
  //这里的id是唯一值，可自行取名；class是bean对象的完整类名，这里就是UserDaolmpl类的完整类名
  

1. 创建一个测试类，并调用Spring的API获得Bean的实例

   @org.junit.Test
   public void test1(){
       ApplicationContext app =new ClassPathXmlApplicationContext("applicationContex.xml");
       UserDaoImp userDao = (UserDaoImp) app.getBean("userDao");
       userDao.show();
   }
   

   • applicatContext：接口类，代表应用上下文，可以通过getBean(id名)来获取Spring的bean对象
   • ClassPathXmlApplicationContext（“Spring配置文件名”）：从类的根路径来加载Spring配置文件。
     • FileSystemXmlApplicationContext：它是从磁盘路径上加载配置文件，配置文件可以在磁盘的任意位置。
     • AnnotationConfigApplicationContext：当使用注解配置容器对象时，需要使用此类来创建 spring 容器。它用来读取注解
   • getBean:可以通过在容器中的设置好的Bean的id名来获取对象

2. 小结：Spring的开发步骤

   1.导入坐标
   2.创建Baen（要放到Spring容器中的类）
   3.创建Spring核心配置文件applicationContext.xml
   4.在配置文件中进行相应的配置
   5.创建ApplicationContext对象getBean
   

---

Spring配置文件

• Bean标签的基本配置

  • Bean标签是用于配置对象交由Spring来创建，默认情况下它是调用类中的无参构造方法来创建对象

  • 基本属性

    • id：Bean实例在Spring容器中的唯一标识

    • class：Bean的全限定名称

    • scope：指对象的作用范围，取值如下

      取值范围	说明
      singleton	默认值，单例的
      prototype	多例的
      request	WEB 项目中，Spring 创建一个 Bean 的对象，将对象存入到 request 域中
      session	WEB 项目中，Spring 创建一个 Bean 的对象，将对象存入到 session 域中
      global session	WEB 项目中，应用在 Portlet 环境，如果没有 Portlet 环境那么globalSession 相当

    • singleton(单例模式)：在每个Spring IoC容器中一个bean定义对应一个对象实例
      prototype(原型模式/多例模式)：一个bean（对象）定义对应多个对象实例

• Bean生命周期的相关配置

  • init-method:指定类中的初始化方法名称

  • destroy-method:指定类中的销毁方法名称

  • //实现类
    public class UserDaolmpl implements UserDao {
        public void show() {
            System.out.println("run...Spring");
        }
      //此方法为Spring创建后就会执行的方法
      public void init(){
        System.out.println("初始化方法");
      }
      //此方法为Spring销毁后执行的方法
       public void destroy(){
        System.out.println("销毁方法");
      }
    }
    

  • 在配置文件中加上相应的属性

  •  <bean id="userDao" class="com.itheima.dao.UserDaolmpl" init-method="init"destroy-method="destroy" ></bean>
    

• Bean实例化的3中方式

  1. 无参构造方法实例化
  2. 工厂静态方法实例化
  3. 工厂实例方法实例化

  • 使用无参构造方法实例化：*默认无参构造方法来创建类对象，如果bean中没有默认无参构造函数，将会创建失败

     <bean id="userDao" class="com.itheima.dao.UserDaolmpl" ></bean>
    

  • 工厂静态方法实例化:就是先创建一个类实现一个返回相应对象的静态方法

    public class StaticFactory {
        public static UserDaolmpl getUser(){
            return new UserDaolmpl();
        }
    }
    

    <bean id="userDao" class="com.itheima.factory.StaticFactory" factory-method="getUser"></bean>
    

    factory-method:调用类中的getUSer方法

  • 工厂实例方法实例化

    public class DynamicFactory {
            public  UserDao createUserDao() {
                return new UserDaolmpl();
            }
        }
    

    <bean id="factoyBean" class="com.itheima.factory.DynamicFactory" ></bean>-->
    <bean id="userDao" factory-bean="factoryBean" factory-method="createUserDao"/>
    

    factory-bean="factoryBean“ factory-method="createUserDao:代表userDao要找factoryBean类中的createUserDao方法

  ---

• Bean的依赖注入

依赖注入（Dependency Injection）：它是 Spring 框架核心 IOC 的具体实现在编写程序时，通过控制反转，把对象的创建交给了 Spring，但是代码中不可能出现没有依赖的情况。IOC 解耦只是降低他们的依赖关系，但不会消除。例如：业务层仍会调用持久层的方法。那这种业务层和持久层的依赖关系，在使用 Spring 之后，就让 Spring 来维护了。简单的说，就是坐等框架把持久层对象传入业务层，而不用我们自己去获取。

Spring依赖注入案例

• set方法实现

1. 先创建Userscrvice接口再创建一个实现接口的类：简单的用来代替业务层。

   //接口
   public interface UserService {
       public void show();
   }
   //实现类
   public class UserServiceImp implements UserService {
       private UserDaoImp userDaoImp;//创建一个Dao的对象
   
       public void setUserDaoImp(UserDaoImp userDaoImp) {
           this.userDaoImp = userDaoImp;
       }
   
       @Override
       public void show() {//模拟业务层调用持久层的方法
           userDaoImp.show();
       }
   }
   

2. 在Spring配置文件中添加配置

   <bean id="userDao" class="com.itheima.dao.impl.UserDaoImpl"/>
   <bean id="userService" class="com.itheima.service.impl.UserServiceImpl"> 
     <property name="userDao" ref="userDao"/>
   </bean>
   

   • property:set方法的配置语法 name:指定set后面的参数名，第一个字母要小写。本例中setUserDaoImp,因此这里写userdao ，ref:引用bean的id名。

3. 编写测试方法

   public class UserController {
       public static void main(String[] args) {
           ApplicationContext app =new ClassPathXmlApplicationContext("applicationContex.xml");
           UserService userService = (UserService) app.getBean("userService");
           userService.show();
       }
   }
   
   

---

• 构造方法实现

  public class UserServiceImp implements UserService {
      private UserDaoImp userDaoImp;//创建一个Dao的对象
  
    public void UserServiceImp( UserDaoImp userDaoImp){
      this.userDaoImp=userDaoImp;
    }
  
      @Override
      public void show() {//模拟业务层调用持久层的方法
          userDaoImp.show();
      }
  }
  

  在Spring配置文件中配置

  <bean id="userDao" class="com.itheima.dao.impl.UserDaoImpl"/>
  <bean id="userService" class="com.itheima.service.impl.UserServiceImpl">
    <constructor-arg name="userDao" ref="userDao"></constructor-arg>
  </bean>
  

  constructor-arg:构造 name:构造方法里参数的名字ref：bean的引用

---

Bean的依赖注入的数据类型

上面的操作都属于 引用数据类型的注入，注入数据的有三种数据类型：

• 普通数据类型
• 引用数据类型
• 集合数据类型

下面代码演示

1. 编写dao类

   public class UserServiceImp2 implements UserService {
       private UserDaoImp userDaoImp;
       private String name;
       private int age;
       private List<String> stringList;
       private List<User> userList;
       private Map<String,User> map;
       private Properties pro;
   
       public void setPro(Properties pro) {
           this.pro = pro;
       }
   
       public void setMap(Map<String, User> map) {
           this.map = map;
       }
   
       public void setUserList(List<User> userList) {
           this.userList = userList;
       }
   
       public void setStringList(List<String> stringList) {
           this.stringList = stringList;
       }
   
       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 UserServiceImp2(UserDaoImp userDaoImp) {
           this.userDaoImp = userDaoImp;
       }
       public UserServiceImp2(){}
   
       @Override
       public void show() {
           userDaoImp.show();
           System.out.println(name+"=="+age);
           System.out.println(stringList);
           System.out.println(userList.toString());
           System.out.println(map.toString());
           System.out.println(pro);
       }
   }
   
   

   1. 配置Spring配置文件：

          <bean id="userDao" class="com.itheima.dao.UserDaompl"></bean> 
          <bean id="userService" class="com.itheima.demo.UserServiceImp" p:userDaoImp-ref="userDao"></bean>
          <bean id="userService2" class="com.itheima.demo.UserServiceImp2" >
                 <!--        引用类型的注入-->
              <constructor-arg name="userDaoImp" ref="userDao"></constructor-arg>
               <!--        String的注入-->
              <property name="name" value="zhangsan"></property>
              <property name="age" value="18"></property>
              <!--        list<String>的注入-->
              <property name="stringList" >
                  <list>
                      <value>aaa</value>
                      <value>bbb</value>
                      <value>ccc</value>
                  </list>
              </property>
              <!--        list<user>的注入-->
              <property name="userList">
                  <list>
                      <ref bean="user1"></ref>
                      <ref bean="user2"></ref>
                  </list>
              </property>
              <!--        map的注入-->
              <property name="map">
                  <map>
                      <entry key="user1" value-ref="user1"></entry>
                      <entry key="user2" value-ref="user2"></entry>
                  </map>
              </property>
      <!--        Properties的注入-->
              <property name="pro">
                  <props>
                      <prop key="p1">aaa</prop>
                      <prop key="p2">bbb</prop>
                      <prop key="p3">ccc</prop>
                  </props>
              </property>
      
      
          </bean>
      <!--       user的注入-->
          <bean id="user1" class="com.itheima.demo.User">
              <property name="name" value="lisi"></property>
              <property name="dizi" value="beijing"></property>
          </bean>
          <bean id="user2" class="com.itheima.demo.User">
              <property name="name" value="wangwu"></property>
              <property name="dizi" value="tianjing"></property>
          </bean>
      

---

总结

<bean>标签
id属性:在容器中Bean实例的唯一标识，不允许重复
class属性:要实例化的Bean的全限定名
scope属性:Bean的作用范围，常用是Singleton(默认)和prototype
<property>标签：属性注入
name属性：属性名称
value属性：注入的普通属性值
ref属性：注入的对象引用值
<list>标签
<map>标签
<properties>标签
<constructor-arg>标签
<import>标签:导入其他的Spring的分文件实际开发中，

Spring的配置内容非常多，这就导致Spring配置很繁杂且体积很大，所以，可以将部分配置拆解到其他
配置文件中，而在Spring主配置文件通过import标签进行加载

<import resource="applicationContext-xxx.xml"/>