Spring入门笔记01

2019-04-17 本文已影响0人 itzhouq的笔记

Spring笔记01

１.　Spring介绍

1.1 Spring概述

Spring是一个开源框架，Spring是于2003 年兴起的一个轻量级的Java 开发框架，由Rod Johnson 在其著作Expert One-On-One J2EE Development and Design中阐述的部分理念和原型衍生而来。它是为了解决企业应用开发的复杂性而创建的。Spring使用基本的JavaBean来完成以前只可能由EJB完成的事情。然而，Spring的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言，任何Java应用都可以从Spring中受益。简单来说，Spring是一个轻量级的控制反转（IoC）和面向切面（AOP）的容器框架。

1.2 Spring好处

方便解耦，简化开发
- Spring就是一个大工厂，专门负责生成Bean，可以将所有对象创建和依赖关系维护由Spring管理。通过Spring提供的IoC容器，可以将对象间的依赖关系交由Spring进行控制，避免硬编码所造成的过度程序耦合。用户也不必再为单例模式类、属性文件解析等这些很底层的需求编写代码，可以更专注于上层的应用。
AOP变成的支持
- Spring提供面向切面编程，可以方便的实现对程序进行权限拦截，运行监控等功能。通过Spring的AOP功能，方便进行面向切面的编程，许多不容易用传统OOP实现的功能可以通过AOP轻松应付。
声明式事务的支持
- 只需要通过配置就可以完成对事务的管理，而无需手动编程
方便程序的测试
- Spring对Junit4支持，可以通过注解方便的测试Spring程序
方便集成各种优秀框架
- Spring不排斥各种优秀的开源框架，其内部提供了对各种优秀框架的支持，如Struts、Hibernate、Mybatis、Quartz等
降低JavaEE API的使用难度
- 对JavaEE开发中一些难用的API（JDBC、JavaMail、远程调用等），都提供了封装，使这些API应用难度大大降低
Java源码是经典学习范例
- Spring的源代码设计精妙、结构清晰、匠心独用，处处体现着大师对Java设计模式灵活运用以及对Java技术的高深造诣。它的源代码无意是Java技术的最佳实践的范例。

1.3 Spring结构体系

Spring框架是一个分层架构，它包含一系列的功能要素并被分为大约20个模块。这些模块分为Core Container、DataAccess/Integration、Web、AOP、Instrumentation和测试部分。如下图所示：

Spring体系结构

1.4 在项目中的架构

web层：Struts，SpringMVC
dao层：Hibernate，Mybatis

架构图

1.5 程序的耦合和解耦

程序的耦合

我们开发种，会写很多的类，而有些类之间不可避免地产生依赖关系，这种依赖关系称为耦合。有些依赖是必须的，有些依赖关系可以通过优化代码来解除。比如：
```
/**
 * 客户的业务层实现类
 */
public class CustomerServiceImpl implements ICustomerService {
    
    private ICustomerDao customerDao = new CustomerDaoImpl();   
}
```
上面的代码表示：业务调用持久层，并且此时业务再依赖持久层的接口和实现类。如果此时没有持久层实现类，编译将不能通过。这种依赖关系就是我们可以通过优化代码解决的。

再比如：下面的代码种，我们的类依赖MySQL的具体驱动类，如果这狮虎更换了数据库品牌，我们需要改源码来修修改数据库驱动，这显然不是我们想要的。

public class JdbcDemo1 {
    
    /**
     * JDBC操作数据库的基本入门中存在什么问题？
     *    导致驱动注册两次是个问题，但不是严重的。
     *    严重的问题：是当前类和mysql的驱动类有很强的依赖关系。
     *               当我们没有驱动类的时候，连编译都不让。
     * 那这种依赖关系，就叫做程序的耦合
     * 
     * 我们在开发中，理想的状态应该是：
     *    我们应该尽力达到的：编译时不依赖，运行时才依赖。
     *   
     * @param args
     * @throws Exception
     */
    public static void main(String[] args) throws Exception {
        //1.注册驱动
        //DriverManager.registerDriver(new com.mysql.jdbc.Driver());
        Class.forName("com.mysql.jdbc.Driver");
        //2.获取连接
        //3.获取预处理sql语句对象
        //4.获取结果集
        //5.遍历结果集
    }

解决程序耦合的思路
- 在JDBC种是通过反射来注册驱动的，代码如下：
```
Clas.forName("com.mysql.jdbc.Driver");
```
- 这时的好处是，我们类中不再依赖具体的驱动类，此时就算删除MySQL的驱动jar包，依然可以编译。但是没有驱动类，所以不能运行。
- 不过，此处也有一个问题，就是我们反射类对象的全限定类名字符串是在Java类中写死的，一旦要改还是徐娅修改源码。为了解决这个问题，使用配置文件配置。
工厂模式解耦
- 在实际开发过程总我们把所有的dao和service和action对象使用配置文件配置起来，当启动服务器应用加载的时候，通过读取配置文件，把这些对象创建出来并存起来。在接下来使用的时候，直接拿就好了。
控制反转---Inversion Of Control
- 上面解耦的思路有两个问题
  1. 创建的对象存储在哪里？由于我们是很多对象，肯定要找个集合来存储，这时候有Map和List供选择。到底是选择Map还是List就看我们有没有查找的需求。有查找的需求就选Map。所以我们的答案是：在应用加载时，创建一个Map，用于存放action，service和dao对象。
  2. 还是没解释什么是工厂?工厂就是负责给我们从容器中获取指定对象的类。这时候获取对象的方式发生了改变。以前，我们在获取对象的时候，都是采用new的方式，是主动的。

现在，我么获取对象的时候，同时跟工厂要，有工厂为我们查找或者创建对象。是被动的。这种被动接收的方式获取对象的思想就是控制反转，他是Spring框架的核心之一。其作用只有一个：降低计算机程序的耦合。

Snipaste_2019-04-16_22-08-19.png

2. Spring快速入门

使用spring的IOC解决程序耦合

2.1 编写流程

下载Spring开发包
导入Spring的jar包
配置Spring的核心xml文件
在程序中读取Spring的配置文件来获取Bean【Bean其实就是一个new好的对象】

2.2 下载地址

这里下载4.2.4版本
地址：<http://repo.spring.io/release/org/springframework/spring/4.2.4.RELEASE//>
官网：spring.io 官网改版后，下载链接需要在对应的GitHub上找

2.3 Spring的核心jar包

spring-core-4.2.4.RELEASE.jar包含Spring框架基本的核心工具类，Spring其他组件都要使用到这个包里得嘞，是其他组件的基本核心。
spring-beans-4.2.4.RELEASE.jar所有应用都要用到的，它包含访问配置文件、创建和管理bean

以及进行Inversion of Control(IoC) / Dependency Injection(DI)操作相关的所有类。
spring-context-4.2.4.RELEASE.jarSpring提供在基础IoC功能上的扩展服务，此外还提供许多企业级服务的支持,

如邮件服务、任务调度、JNDI定位、EJB集成、远程访问、缓存以及各种视图层框架的封装等。
spring-expression-4.2.4.RELEASE.jarSpring表达式语言。
com.springsource.org.apache.commons.logging-1.1.1.jar第三方的主要用于处理日志。

2.4 Spring入门案例

准备项目需要得jar包
- spring-framework-4.2.4.RELEASE-dist.zip 【Spring的核心包】
- spring-framework-4.2.4.RELEASE-dependencies.zip 【Spring的依赖包】
创建Project，导入Spring的jar包

在src路径下创建applicationContext.xml文件

导入约束

把资源交给Spring管理，在xml文件中配置User

<?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-framework-4.2.4.RELEASE\docs\spring-framework-reference\html\xsd-configuration.html
        文档末尾 -->
    <!-- 
        1. 基本配置：
            bean标签：指定要创建的实体类
            id属性：可以为任意值 但是在整个配置文件中唯一
            class属性：要实例化类的全限定名 反射
     -->
    <bean id="user" class="com.itzhouq.domain.User"></bean>

</beans>

测试

package com.itzhouq.domain;

public class User {
    public void run() {
        System.out.println("run");
    }

}

package com.itzhouq.test;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.itzhouq.domain.User;

public class UserTeset {
    
    @Test
    public void test() {//自己new的对象
        User user = new User();
        user.run();
    }
    
    @Test
    public void test2() {//spring的ioc创建对象
        //加载配置文件  src/classes类路径
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        //找Spring要对象
        User user = (User) context.getBean("user");
        user.run();
    }
}

3. Spring基于XML的IOC细节

3.1 IOC中bean标签和管理对象细节

3.1.1 配置文件bean标签

作用
- 用于配置对象让Spring来创建的。默认情况下它调用的是类中的无参构造函数。如果没有无参构造函数则不能创建成功。
属性
- id：给对象在容器中提供一个唯一标识，用于获取对象
- class：指定类的全限定名。用于反射创建对象，默认情况下调用无参构造函数。
- scope：指定对象的作用范围。
- init-method：指定类中的初始化方法名称。
- destroy-method:指定类中销毁方法名称。
- import：导入外部配置文件，resource----外部配置文件的地址。

3.1.2 scope属性：范围（重点）

<bean id="user" class="cn.itzhouq.domain.User" scope="singleton" ></bean>

singleton: 单实例默认值
如果是单实例,配置文件文件只要一加载就会创建对象放在spring容器 (map<id,对象>)
当所有人过来问spring容器要的时候(getBean),所用人用的都是同一个对象
prototype: 多实例
- 如果是多实例,配置文件加载,不创建对象
- 当每个人过来getbean的时候,getbean一次创建一次放在容器中
什么时候用默认值singleton(单实例)? 什么时候用prototype(多实例)?
- action: prototype
- service/dao: singleton
request：web项目中Spring创建一个Bean对象，将对象存入到request域中
session：web项目中Spring创建一个Bean对象，将对象存入到session域中。
globalSession：web项目中，应用在Portlet环境，如果没有Portlet环境那么globalSession相当于session。

3.1.3 bean的作用范围和生命周期

单例对象：scope="singleton"
- 一个应用只有一个对象的实例。它的作用范围就是整个引用。
- 生命周期：
  - 对象出生：当应用加载，创建容器时，对象就被创建了。
  - 对象活着：只要容器在，对象一直活着。
  - 对象死亡：当应用卸载，销毁容器时，对象就被销毁了。
- 多例对象：scope="prototype"
- 每次访问对象时，都会重新创建对象实例。
- 生命周期：
  - 对象出生：当使用对象时，创建新的对象实例。
  - 对象活着：只要对象在使用中，就一直活着。
  - 对象死亡：当对象长时间不用时，被java的垃圾回收器回收了。

3.1.4 示例化Bean的三种方式

无参构造方式（最常用）

@Test//测试bean的三种创建方式------无参构造方式
  public void test3() {
      //加载配置文件  src/classes类路径
      ApplicationContext context = new        ClassPathXmlApplicationContext("applicationContext.xml");
      //找Spring要对象
      User user = (User) context.getBean("user");
      user.run();
  }

静态工厂方式（了解）

条件：需要有一个工厂类，在这个工厂类中还需要一个静态方法

package com.itzhouq.utils;

import com.itzhouq.domain.User;

public class BeanFactory {
    
    public static User createUser() {
        return new User();
    }

}

<!-- 静态工厂方式 -->
    <bean id="user" class="com.itzhouq.utils.BeanFactory" factory-method ="createUser">

测试

@Test//测试bean的三种创建方式------静态工厂方式
    public void test4() {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        User user1 = (User) context.getBean("user");
        System.out.println(user1);//com.itzhouq.domain.User@5f3a4b84
        User user2 = (User) context.getBean("user");
        System.out.println(user2);//com.itzhouq.domain.User@5f3a4b84
    }

实例工厂方式（了解）

条件：需要一个工厂类在这个工厂类中需要一个普通方法

package com.itzhouq.utils;

import com.itzhouq.domain.User;

public class BeanFactory {
  
//    public static User createUser() {
//        return new User();
//    }
  
  //普通方法----实例工厂
  public User createUser() {
      return new User();
  }
}

配置文件

<!-- 实例工厂 -->
   <bean id="beanFactory" class="com.itzhouq.utils.BeanFactory"></bean>
   <bean id="user" factory-bean="beanFactory" factory-method="createUser"></bean>

测试

@Test//测试bean的三种创建方式------实例工厂方式
    public void test5() {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        User user1 = (User) context.getBean("user");
        System.out.println(user1);//com.itzhouq.domain.User@5f3a4b84
        User user2 = (User) context.getBean("user");
        System.out.println(user2);//com.itzhouq.domain.User@5f3a4b84
    }

3.2 加载Spring容器的三种方式

类路径获得配置文件
文件系统路径获得配置文件
使用BeanFactory（了解）

public class Lession01 {

    @Test
    public void test01(){
        //Spring容器加载有3种方式
        //第一种：ClassPathXmlApplicationContext    ClassPath类路径加载：指的就是classes路径
        //最常用，Spring的配置文件以后就放在src路径下
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");

        //第二种方式：文件系统路径获得配置文件【绝对路径】
        ApplicationContext context = new FileSystemXmlApplicationContext("E:\\workspaces\\IdeaProject\\Spring-day02-gyf\\src\\beans.xml");

        IUserService user = (IUserService) context.getBean("userService");
        user.add();

        //第三种方式：
        String path = "E:\\workspaces\\IdeaProject\\Spring-day02-gyf\\src\\beans.xml";
        BeanFactory factory = new XmlBeanFactory(new FileSystemResource(path));
        IUserService user1 = (IUserService) factory.getBean("userService");
        user1.add();
    }
}

Spring内部创建对象的原理

1. 解析xml文件，获得类名，id，属性
2. 通过反射，用类型创建对象
3. 给创建的对象赋值

3.3 BeanFactory和ApplicationContext对比

BeanFactory采用延迟加载，第一次getBean时才会初始化Bean
ApplicationContext是对BeanFactory扩展，提供了更多功能
- 国际化处理
- 事件传递
- Bean自动装配
- 各种不同应用的Context实现

3. 4 Spring的依赖注入DI

DI属性的依赖注入，是Spring框架核心IoC的具体实现方式。Spring在通过Ioc创建对象的时候，如果这个对象还有属性，就一并赋值进去，而不用我们自己去获取。

入门举例：

创建一个接口Car

package com.itzhouq.service;

public interface Car {
    public void run();
}

创建实现类CarImpl

package com.itzhouq.serviceImpl;

import com.itzhouq.service.Car;

public class CarImpl implements Car {
    private String name;
    
    public void setName(String name) {
        this.name = name;
    }


    @Override
    public void run() {
        System.out.println(name+"车跑起来了.....");
    }
}

测试

package com.itzhouq.test;
import org.junit.Test;
import com.itzhouq.serviceImpl.CarImpl;
public class CarTest {  
    @Test//自己new对象 自己属性赋值的方式
    public void test() {
        CarImpl car = new CarImpl();
        car.setName("qq");
        car.run();//qq车跑起来了.....
    }
}

入门举例2：依赖注入的方式

配置文件：

<!-- DI：属性的依赖注入 -->
   <bean id="car" class="com.itzhouq.serviceImpl.CarImpl">
        <!-- 
            property：是set属性的方式
            name：要赋值的属性名
            value：要赋的值
         -->
         <property name="name" value="兰博基尼"></property>
   </bean>

测试

@Test   //Spring的IOC
    public void test2() {
        ApplicationContext context = new ClassPathXmlApplicationContext("ApplicationContext.xml");
        Car car = (Car)context.getBean("car");
        //把这个对象的属性也在创建的时候给顺便赋值了-----DI
        car.run();//兰博基尼车跑起来了.....
    }

依赖注入的方式
- 构造函数注入（了解）
- set方法注入（掌握）
- 使用p名称空间注入数据（本质还是调用set方法）（了解）
- 注入集合属性

3.4.1 构造器注入方式

条件：需要有有参构造方法

给CarImpl设置有参构造

package com.itzhouq.serviceImpl;

import com.itzhouq.service.Car;

public class CarImpl implements Car {
  private String name;
  private double price;
  public void setName(String name) {
      this.name = name;
  }
  public double getPrice() {
      return price;
  }
  public void setPrice(double price) {
      this.price = price;
  }
  public String getName() {
      return name;
  }
  public CarImpl() {}
  //有参的构造方法----DI的构造器注入方式
  public CarImpl(String name, double price) {
      super();
      this.name = name;
      this.price = price;
  }
  @Override
  public void run() {
      System.out.println("价值"+price+"的"+name+"车跑起来了.....");
  }
}

配置文件

<!-- DI的注入方式,构造器注入方式 
          name:要赋值的属性名
          value：要赋的值（针对的是基本数据类型和String类型）
          ref针对的是对象类型
   -->
   <bean id="car" class="com.itzhouq.serviceImpl.CarImpl">
          <constructor-arg name="name" value="BMW"></constructor-arg>
          <constructor-arg name="price" value="1000000"></constructor-arg>
   </bean>

测试

@Test   //Spring的DI注入方式----构造器的注入方式（了解）
  public void test3() {
      ApplicationContext context = new ClassPathXmlApplicationContext("ApplicationContext.xml");
      Car car = (Car)context.getBean("car");
      car.run();//价值1000000.0的BMW车跑起来了.....
  }

3.4.2 set方式注入

写一个Person接口

package com.itzhouq.service;

public interface Person {
}

PersonImpl实现接口Person,设置set方法

package com.itzhouq.serviceImpl;

import com.itzhouq.service.Car;
import com.itzhouq.service.Person;

public class PersonImpl implements Person {
  private String name;
  private Car car;
  public String getName() {
      return name;
  }
  public void setName(String name) {
      this.name = name;
  }
  public Car getCar() {
      return car;
  }
  public void setCar(Car car) {
      this.car = car;
  }
  @Override
  public String toString() {
      return "PersonImpl [name=" + name + ", car=" + car + "]";
  }
}

配置文件

<bean id="car" class="com.itzhouq.serviceImpl.CarImpl">
          <constructor-arg name="name" value="BMW"></constructor-arg>
          <constructor-arg name="price" value="1000000"></constructor-arg>
   </bean>
   
   <!-- DI的注入方式,set注入方式 
          name:要赋值的属性名
          value：要赋的值（针对的是基本数据类型和String类型）
          ref针对的是对象类型,指的是Spring中bean的id名
   -->
   <bean id="person" class="com.itzhouq.serviceImpl.PersonImpl">
          <property name="name" value="jack"></property>
          <property name="car" ref="car"></property>
   </bean>

测试

@Test   //Spring的DI注入方式----set的注入方式（了解）
  public void test4() {
      ApplicationContext context = new ClassPathXmlApplicationContext("ApplicationContext.xml");
      Person person = (Person) context.getBean("person");
      System.out.println(person);
      //PersonImpl [name=jack, car=CarImpl [name=BMW, price=1000000.0]]
  }

3.4.3 使用p名称空间注入数据(知道就OK)

此种方式是通过在xml中导入p名称空间，使用p:propertyName来注入数据，它的本质仍然是调用类中的set方法实现注入功能。

配置文件

<beans xmlns="http://www.springframework.org/schema/beans"
      xmlns:p="http://www.springframework.org/schema/p"
         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="customerService" 
        class="com.itheima.service.impl.CustomerServiceImpl4"
        p:name="test" p:age="21" p:birthday-ref="now"/>
</beans>

3.4.4 注入集合属性

顾名思义，就是给类中的集合成员传值，它用的也是set方法注入的方式，只不过变量的数据类型都是集合。我们这里介绍注入数组，List,Set,Map,Properties。

创建一个类CollBean，设置set方法

package com.itzhouq.domain;

import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.Properties;


public class CollBean {
  private String[] ss;
  private List ll;
  private Map mm;
  private Properties properties;
  public String[] getSs() {
      return ss;
  }
  public void setSs(String[] ss) {
      this.ss = ss;
  }
  public List getLl() {
      return ll;
  }
  public void setLl(List ll) {
      this.ll = ll;
  }
  public Map getMm() {
      return mm;
  }
  public void setMm(Map mm) {
      this.mm = mm;
  }
  public Properties getProperties() {
      return properties;
  }
  public void setProperties(Properties properties) {
      this.properties = properties;
  }
  @Override
  public String toString() {
      return "CollBean [ss=" + Arrays.toString(ss) + ", ll=" + ll + ", mm=" + mm + ", properties=" + properties + "]";
  }

}

配置文件

<bean id="car" class="com.itzhouq.serviceImpl.CarImpl">
          <constructor-arg name="name" value="BMW"></constructor-arg>
          <constructor-arg name="price" value="1000000"></constructor-arg>
   </bean>
   <!-- DI复杂属性注入 -->
   <bean id="collBean" class="com.itzhouq.domain.CollBean">
          <property name="ss">
              <!-- 数组类型 -->
              <list>
                  <value>aaa</value>
                  <value>bbb</value>
                  <value>ccc</value>
              </list>
          </property>
          <property name="ll">
              <!-- 集合类型 -->
              <list>
                  <value>111</value>
                  <value>222</value>
                  <ref bean="car"></ref>
              </list>
          </property>
          <property name="mm">
              <!-- map类型 -->
              <map>
                  <entry key="k1" value="AAA"></entry>
                  <entry key="k2" value="BBB"></entry>
                  <entry key="k3" value-ref="car"></entry>
              </map>
          </property>
          <property name="properties">
              <!-- properties -->
              <props>
              <prop key="hibernate.username">root</prop>
              <prop key="hibernate.password">1234</prop>
              </props>
          </property>
   </bean>

测试

package com.itzhouq.test;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.itzhouq.domain.CollBean;

public class CollBeanTest {
  @Test
  public void test() {
      ApplicationContext context = new ClassPathXmlApplicationContext("ApplicationContext.xml");
      CollBean cb = (CollBean) context.getBean("collBean");
      System.out.println(cb);
      /*
       * CollBean [ss=[aaa, bbb, ccc], 
       * ll=[111, 222, CarImpl [name=BMW, price=1000000.0]],
       *  mm={k1=AAA, k2=BBB, k3=CarImpl [name=BMW, price=1000000.0]}, 
       *  properties={hibernate.password=1234, hibernate.username=root}]
       */
  }
}

4. 使用案例

需求分析：从service层调用dao层，将数据存储到数据库，存储数据的过程使用syso模拟一下就可以。
创建工程，导入需要的jar包，建包如下：

创建dao层和dao实现层

package com.itzhouq.dao;

public interface UserDao {
  void save();
}

package com.itzhouq.daoImpl;

import com.itzhouq.dao.UserDao;

public class UserDaoImpl implements UserDao{

  @Override
  public void save() {
      System.out.println("操作数据库，保存用户的数据");    
  }
}

创建Service层和实现层

package com.itzhouq.service;

public interface UserService {
  public void save();
}

package com.itzhouq.serviceImpl;

import com.itzhouq.dao.UserDao;
import com.itzhouq.daoImpl.UserDaoImpl;
import com.itzhouq.service.UserService;

public class UserServiceImpl implements UserService {
  private String name;
  private UserDao userDao;
  public void setUserDao(UserDao userDao) {
      this.userDao = userDao;
  }
  public void setName(String name) {
      this.name = name;
  }

  @Override
  public void save() {
      System.out.println(name);
      //调用dao
      userDao.save();
  }
}

给UserDaoImpl一个UserDao属性

配置文件

<?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">
  <!-- 创建dao -->
  <bean id="userDao" class="com.itzhouq.daoImpl.UserDaoImpl"></bean>
  
  <!-- 创建service -->
  <bean id="UserService" class="com.itzhouq.serviceImpl.UserServiceImpl">
      <property name="name" value="要开始访问dao了"></property>
      <property name="userDao" ref="userDao"></property>
  </bean>
</beans>

测试

@Test //使用Spring的IOC+DI来实现对象的创建和赋值
  public void test() {
      ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
      UserService userService = (UserService) context.getBean("UserService");
      userService.save();
      //要开始访问dao了
      //操作数据库，保存用户的数据
  }

Spring入门笔记01

Spring笔记01

１.　Spring介绍

1.1 Spring概述

1.2 Spring好处

1.3 Spring结构体系

1.4 在项目中的架构

1.5 程序的耦合和解耦

2. Spring快速入门

2.1 编写流程

2.2 下载地址

2.3 Spring的核心jar包

2.4 Spring入门案例

3. Spring基于XML的IOC细节

3.1 IOC中bean标签和管理对象细节

3.1.1 配置文件bean标签

3.1.2 scope属性：范围（重点）

3.1.3 bean的作用范围和生命周期

3.1.4 示例化Bean的三种方式

3.2 加载Spring容器的三种方式

3.3 BeanFactory和ApplicationContext对比

3. 4 Spring的依赖注入DI

3.4.1 构造器注入方式

3.4.2 set方式注入

3.4.3 使用p名称空间注入数据(知道就OK)

3.4.4 注入集合属性

4. 使用案例

猜你喜欢

热点阅读

Spring入门笔记01

Spring笔记01

１. Spring介绍

1.1 Spring概述

1.2 Spring好处

1.3 Spring结构体系

1.4 在项目中的架构

1.5 程序的耦合和解耦

2. Spring快速入门

2.1 编写流程

2.2 下载地址

2.3 Spring的核心jar包

2.4 Spring入门案例

3. Spring基于XML的IOC细节

3.1 IOC中bean标签和管理对象细节

3.1.1 配置文件bean标签

3.1.2 scope属性：范围（重点）

3.1.3 bean的作用范围和生命周期

3.1.4 示例化Bean的三种方式

3.2 加载Spring容器的三种方式

3.3 BeanFactory和ApplicationContext对比

3. 4 Spring的依赖注入DI

3.4.1 构造器注入方式

3.4.2 set方式注入

3.4.3 使用p名称空间注入数据(知道就OK)

3.4.4 注入集合属性

4. 使用案例

猜你喜欢

热点阅读

１.　Spring介绍