spring框架1

 

spring优点

• 低侵入设计，代码的污染极地
• 独立于各种应用服务器，基于Spring框架的应用，可以真正实现Write  Once ，Run Anywhere的承若
• Spring的IoC容器降低了业务对象替换的复杂性，提高了组件之间的解耦
• Spring的AOP支持将一些通用的任务和安全、事务、日志等进行集中式管理，从而提供了更好的复用
• Spring的ORM和DAO提供了与第三方持久层框架的良好整合，并简化了底层的数据库访问。
• Spring的高度开放性，并不强制应用完全依赖于Spring，开发者可*选用Spring框架的部分或全部

Spring框架的组成结构图如下所示

Spring有两个核心模块

1.控制反转（Inversion  Of  Control）(IOC)容器  （依赖注入dependency injection(DI)）

2.面向切面编程AOP(Aspect  Oriented  Programming)

IOC控制反转

• 控制反转它不是什么技术，而是一种设计思想
• 传统的Java  SE程序设计，我们直接在对象内部通过new进行创建对象，是程序主动去创建对象；而IoC是有专门一个容器来创建这些对象，是程序主动去创建依赖对象；而IoC是专门一个容器来创建这些对象，即由IoC容器来控制对象的创建；
• IoC控制反转将对象的创建权交给了Spring，我们通过Spring，就不用每次去创建对象，只需要通过Spring容器调用getBean(name属性或id属性)获取对应的对象

//spring.xml文件
<?xml version="1.0" encoding="UTF-8"?>

<--
xmlns:xml  namespace (命名空间)

-->

<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标签，创建bean对象
1.通过无参数的构造方法创建对象
2.通过静态方法创建对象
3.通过工厂方式创建对象
class:类名（包名+类名）
id：对象的标识，对象的名称
name:对象的名称
单例模式：singleton
多例模式：prototype
-->
        
    <--通过无参构造方法创建对象-->
<--通过无参数的的构造方法创建对象-->
    <bean id="user" class="com.zhiyou.modle.User" scope="prototype"></bean>

<!--
    2.通过静态方法创建对象
        factory-method:静态方法名称
-->
    <bean name="single" class="com.zhiyou.model.SingleTon"
        factory-method="getInstance"></bean>


3.使用实例工厂方法创建对象

  <bean name="factory" class="com.zhiyou.model.Factory" ></bean>
      <bean name="user2" class="com.zhiyou.model.User" 
       factory-bean="factory"  factory-method="getPeople"
       ></bean>


</beans>

 

//单例模式 singleton

package  coom.zhiyou.modle;


public  class  SingleTon{
    
    static SingleTon singleTon;
    //提供私有方法
    private SingleTon(){


}
    //提供一个静态的获取唯一对象的方法
    public static SingleTon getInstance(){
        
        if(singleTon==null){

        singleTon= new SingleTon();
        }
        return singleTon

        }

}

/**
    modle包下的user
*/
    
package com.zhiyou.model;

public class User extends People {
	
	public void running(){
		System.out.println("running...");
	}

}

/**
      modle包下的Factory
*/
public class Factory {

	
	public People getPeople(){
		return new User();
	}
	
}
/**
     modle包下的People
*/
public class People {

}




-----------------------------------------------------------------------


/**
    1.通过springIOC容器创建对象
    2.classPath对应的是src文件夹
    3.基于classpath的路径
     
*/

   
    ClassPathXmlApplicationContext  context = new 
        ClassPathXmlApplicationContext("spring.xml");

    User user =(User)Context.getBean("user");
    user.running();


    SingleTon singleTon = (SingleTon)context.getBean("single");
    System.out.println(singleTon);


    User user2 = context.getBean("user2");
    system.out.println(user2)

依赖注入

1.设值注入

设值注入是指IoC容器通过成员变量的setter方法来注入被依赖对象。这种注入方式简单、直观，因而在Spring的依赖注入里大量使用。

//UserDaoImpl类


package com.zhiyou.dao.impl;

import com.zhiyou.dao.UserDao;

public class UserDaoImpl implements UserDao {

	@Override
	public void addUser(String name) {
		// TODO Auto-generated method stub
		System.out.println("把用户"+name+"添加到数据库中了");		
	}

}



//UserServiceImpl类

package com.zhiyou.service.impl;

import com.zhiyou.dao.UserDao;
import com.zhiyou.dao.impl.UserDaoImpl;
import com.zhiyou.service.UserService;

public class UserServiceImpl implements UserService {

	UserDao userDao;
	String name;
	
	public void setName(String name) {
		this.name = name;
	}
	
	public void setUserDao(UserDao userDao) {
		this.userDao = userDao;
	}
	
	public UserServiceImpl() {
		// TODO Auto-generated constructor stub
	}
	
	public UserServiceImpl(UserDao userDao) {
		// TODO Auto-generated constructor stub
		System.out.println("构造方法");
		this.userDao = userDao;
	}
	
	
	@Override
	public void addUser(String name) {
		// TODO Auto-generated method stub
		userDao.addUser(this.name);
	}

}

<!--属性赋值

property:使用setter方法给属性赋值
        name:属性名称
        ref:属性值（对象的名称）
        value：属性值
        简单类型：（基本数据类型+String）使用value
        其他引用类型使用ref

-->

<bean id="userDaoImpl" class="com.zhiyou.dao.impl.UserDaoImpl"></bean>

<bean id="userService" class="com.zhiyou.service.impl.UserServiceImpl">
    <property name="userDao ref="userDaoImpl"></proterty>
    <property name="name" value="李四"></proterty>
</bean>


<!--
    通过构造方法给属性赋值：
        使用constructor-arg标签
            name：构造方法参数名（属性名）
                ref:对象名称

-->

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



//集合通过setter方法注入值
 <bean id="proService" class="com.zhiyou.service.impl.PropertyServiceImpl">
   		<property name="list" >
   			<list>
   				<value>abc</value>
   				<value>张三</value>
   			</list>
   		</property>
   		<property name="newList">
   			<list>
   				<value>20</value>
   				<value>hello</value>
   				<ref bean="user"/>
   			</list>
   		</property>
   		<property name="map">
	   		<map>
	   			<entry key="key1" value="aaa"></entry>
	   			<entry key="key2" value-ref="user"></entry>
	   		</map>
   		</property>
   		
   </bean>





        
   <!-- 
   		autowire：自动注入（自动给属性赋值）
   		byName：根据名称匹配进行赋值（在spring配置文件中查找和属性名称一模一样的bean对象）
   		byType: 根据类型匹配进行赋值(在spring配置文件中查找和属性类型一致的bean对象)
   				都是通过setter方法进行赋值
   				
    -->
    
 <!--   <bean id="msgDao2" class="com.zhiyou.dao.orcale.MsgDaoOracleImpl"/>  -->
   <bean id="MsgDao" class="com.zhiyou.dao.impl.MsgDaoImpl"></bean>
   
   <bean id="msgService" class="com.zhiyou.service.impl.MsgServiceImpl" autowire="byType" ></bean

set注入图解

 

constructor注入图解

给数组和list集合赋值

给set集合、map集合、properties集合赋值

自动注入(依赖注入)

所谓自动装配，就是将一个 Bean 注入到其他 Bean 的 Property 中

Spring 支持 4 种自动装配模式（bean的autowire属性），如下：

no —— 默认情况下，不自动装配，通过 ref  attribute手动设定。

byName —— 根据 Property 的 Name 自动装配，如果一个 bean 的 id，和另一个 bean 中的 Property 的 name 相同，则自动装配这个 bean 到 Property 中。

byType —— 根据 Property 的数据类型（ Type ）自动装配，如果一个 bean 的数据类型，兼容另一个 bean 中 Property 的数据类型，则自动装配。

constructor —— 根据构造函数参数的数据类型，进行 byType 模式的自动装配。