Spring学习（二）Spring的bean管理（XML）

Bean的实例化方式

1、在Spring里面通过配置文件创建对象
2、bean实例化的三种方式
第一种：使用类的无参数构造函数创建（最常用的方式，第2种和第3种方法一般不用）
  如果类里面没有无参的构造函数，将会出现异常

第二种：使用静态工厂创建
（1）创建类的静态方法，返回类对象
第三种：使用实例工厂创建
（2）创建不是静态的方法，返回类的对象

　　

3、bean标签常用属性
（1）id
　　id表示为该类起一个名字，id属性值一般为小写的类名id=user
   id属性值，不能有特殊符号，为一个单独的单词（user_1错误）
   根据id值得到配置对象
（2）class：创建对象所在类的全路径
 
（3）name：功能和id属性是一样的（现在name属性已经不用了，为了针对整合struts1）
    但是id睡醒不可以有特殊符号，name可以有特殊符号

（4）scope：

默认是单实例的，可以不写，也可以写：

 

多实例必须要写scope="prototype",多实例的应用场景：配置action

 

4、属性注入方法：
4.1 JAVA的属性注入方法：

（1）创建对象的时候，向类里面的属性设置值
（2）属性注入的介绍（3种方式）
 方法一:set方式（用的最多）
 public class User{
     private String name;
     public void setName(String name){
　　    this.name=name;
    }
}

实现：User user=new User();
     user,setName("Zhangsan");

方法二：有参构造
public class user{
  private String name;
  public User(String name){
   this.name=name;
  }
}

实现：
User user=new User("ZhangSan");
第三种：使用接口注入
public interface Dao{
　　public void delete(String name);
}
public class DaoImpl implements Dao{
　　private String name;
　　public void delete(String name){
　　　　this.name=name
　　}
}
4.2、在Spring框架中只支持（1）set方法注入和（2）有参的构造注入
（1）set
Book类：

package cn.itcast.property;

public class Book {
private String bookname;

public void setBookname(String bookname) {
　　this.bookname = bookname;
}
public void demobook(){
　　System.out.println("booknmae="+bookname);
　　}
}

配置文件：

　　<!-- 使用set方法注入属性 -->
　　<bean id="book" class="cn.itcast.property.Book">
　　　　<!-- 注入属性值 name:类里面定义的属性名称 value:设置具体的值
　　　　-->
　　　　<property name="bookname" value="JAVA"></property>
　　</bean>

(2）有参构造
类：

package cn.itcast.property;

public class PropertyDemo1 {
private String username;

public PropertyDemo1(String username) {
　　this.username = username;
}

public void test1() {
　　System.out.println("username....."+username);
　　}

}

配置文件：

　　<bean id="demo" class="cn.itcast.property.PropertyDemo1">
　　　　<constructor-arg name="username" value="小王"></constructor-arg>
　　</bean>

4.3 注入对象类型的属性********重点掌握
1、创建service类和dao类
　　在service中得到dao的对象
2、具体实现过程

　　在service里面把dao作为类属性
   生成dao类型属性的set方法
　　配置文件中注入关系

UserDao类：

package cn.itcast.service;
public class UserDao {
public void add(){
　　　　System.out.println("dao.....");
　　}
}

UserService类：

package cn.itcast.service;

public class UserService {
private UserDao userDao;
public void setUserDao(UserDao userDao) {
　　　　this.userDao = userDao;
}

public void add(){
　　　　System.out.println("service.....");
　　　　//在service中得到到对象，才能调用dao里面的方法
　　　　// UserDao dao=new UserDao();
　　　　// dao.add();
　　　　userDao.add();
　　}
}

配置文件：

 P名称空间注入：（很少用）

注入复杂类型的属性：

1、数组

2、list集合

3、Map集合

4、Properties类型

<bean id="user" class="cn.itcast.property.Person">
<!--数组-->
    <property name="arrs"> 
        <list>
            <value>张三</value>
            <value>李四</value>
            <value>王五</value>
         </list>
    </property>
<!--list-->
    <property name="list"> 
        <list>
            <value>张三list</value>
            <value>李四list</value>
            <value>王五list</value>
         </list>
    </property>
<!--map-->
    <property name="map"> 
        <map>
            <entry key="a"  value="lucy"></entry>
            <entry key="b"  value="tom"></entry>
            <entry key="c"  value="kate"></entry>
         </map>
    </property>
<!--properties-->
    <property name="properties"> 
        <props>
            <prop  key="driverclass">com.mysql.jdbc.Driver</prop>
            <prop  key="username">root</prop>
            <prop  key="pwd">123</prop>
         </list>
    </property>

</bean>        

Ioc和DI区别：

Ioc:控制反转，把对象的创建交给spring进行配置

DI:依赖注入，向类里面的属性中，设置值

Ioc与DI的关系，依赖注入不可以单独存在，需要在Ioc的基础之上来完成依赖注入的操作

 Spring的bean管理（注解）

注解介绍：

　　- 代码里面特殊的标记，使用注解可以完成功能

　　- 注解写法 @注解名称（属性名称=属性值），例如单元测试@Test

　　- 注解用在什么地方：类、方法、属性都可以使用注解

spring注解开发准备工作

　　-  1、导入jar包

　　　　（1）导入基本jar包

　　　　

　　　　（2）导入aop的jap包

　　　　 

　　- 2、创建类，创建方法

　　- 3、创建Spring配置文件

　　（1）不用注解方式，引入约束 beans,即

　　<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">

　　　</beans>

　　（2）引入新的约束

　　　　

　　- 4、开启注解扫描

    <!-- 开启注解扫描
        (1)到包里面扫描类、方法、睡醒上面是否有注解
     -->
    <context:component-scan base-package="cn.itcast"></context:component-scan>

- 使用注解创建对象（可以替换配置文件，但是不可以完全脱离配置文件）

1、在创建对象的类上面使用注解实现

@Component(value="user")
public class User {
}

测试代码：

ApplicationContext context=new ClassPathXmlApplicationContext("bean1.xml"); 
        User user=(User) context.getBean("user");
        System.out.println("user==="+user);
        user.add();

2、spring中提供的注解方式除了
（1）@Component      还有三个衍注解，是为了让标注类本身的用途更加的清晰
（2）@Controller     WEB 层
（3）@Service        业务层
（4）@Repository     持久层
这四个注解的功能是一样的

3、创建对象的单实例还是多实例

@Component(value="user")
@Scope(value="prototype")//singleton
public class User {
}

- 注解方式来注入属性

（配置文件只有一行：<context:component-scan base-package="cn.itcast"></context:component-scan>）

 1、创建service类，创建dao类，在service中得到dao的类

　　注入属性第一个注解@Autowired（用的不多）:不需要指定类

　　注入属性第二个注解@Resource(name="userDao")：要指定用的name

@Component(value="userDao")
public class UserDao {
    public void add(){
        System.out.println("dao ....");
    }
}

UserService类

@Service(value="userService")
public class UserService {
    //得到dao 对象
    //1、在service中定义dao类型属性
    // 在dao属性上面使用注解来完成对象注入
    @Autowired
    private UserDao userDao;
    //2、使用注解，不用set方法
    public void add(){
        System.out.println("service......");
        userDao.add();
    }
}

第二种属性注入方式

@Service(value="userService")
public class UserService {
    //得到dao 对象
    //1、在service中定义dao类型属性
    // 在dao属性上面使用注解来完成对象注入
    @Resource(name="userDao")
    private UserDao userDao;
    //2、使用注解，不用set方法
    public void add(){
        System.out.println("service......");
        userDao.add();
    }
}

测试代码：

    public void testDemo(){
        ApplicationContext context=new ClassPathXmlApplicationContext("bean1.xml"); 
        UserService user=(UserService) context.getBean("userService");
        System.out.println("user==="+user);
        user.add();
    }

配置文件和注解混合使用

1、创建对象的操作使用配置文件方式实现

2、注入属性操作注解方式实现

3、例子在BookService中使用BookDao类和OrdersDao类

BookDao类

package cn.itcast.xmlann0;
public class BookDao {
    public void book(){
        System.out.println("bookDao....");
    }
}

OrdersDao类

package cn.itcast.xmlann0;
public class OrdersDao {
    public void buy(){
        System.out.println("ordersbuy....");
    }
}

BookService类

package cn.itcast.xmlann0;

import javax.annotation.Resource;

public class BookService {
    @Resource(name="bookDao")
    private BookDao bookDao;
    @Resource(name="ordersDao")
    private OrdersDao ordersDao;
    public void add(){
        System.out.println("service....");
        bookDao.book();
        ordersDao.buy();
    }
}

bean2.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: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"> <!-- bean definitions here -->
    <!-- 开启注解扫描
        (1)到包里面扫描类、方法、睡醒上面是否有注解
     -->
    <context:component-scan base-package="cn.itcast"></context:component-scan>
    <!-- 配置对象 -->
    <bean id="bookDao" class="cn.itcast.xmlann0.BookDao"></bean>
    <bean id="ordersDao" class="cn.itcast.xmlann0.OrdersDao"></bean>
    <bean id="bookService" class="cn.itcast.xmlann0.BookService"></bean>
</beans>

测试代码：

    @Test
    public void testxmlanno(){
        ApplicationContext context =new ClassPathXmlApplicationContext("bean2.xml");
        BookService bookService=(BookService) context.getBean("bookService");
        bookService.add();
    }

结果：

service....
bookDao....
ordersbuy....