Spring概述

1 .spring 介绍以及spring 框架的优势：
spring框架是一个企业级的轻量级框架，低倾入的框架（也是后期项目维护，修改代码量比较少）
优势：
1：其实spring 就是一个大工厂模式（生产管理实体bean，不用实例化对象，所有的都是通过spring容器来进行管理）
2：支持分布式事务（原子性，一致性，隔离性，持久性）
3：支持测试，与jutext测试有良好的结合；
4：与其他框架的结合度比较好（ssh,ssm）
5：支持企业级的api的开发（邮箱，任务调度)（超级重要的框架）
2 .spring 各个模块的介绍
(1)bean（管理和生产对象）
(2)core（提供一些核心的基础服务）
(3)context（提供api开发）

搭建spring框架的步骤：
1：导入核心的jar包(一共是6个jar包)
2：导入核心配置文件（applicationContext.xml）
3：测试

3 .控制反转(ioc)
控制反转：就是不需要自己来实例化这个对象，而依赖我们容器，也就是spring框架

1：存在一个Boy对象
public class Boy implements Serializable {
    //拥有一个说的方法
    public  void say(){
        System.out.println("正在说话！");
    }}
 2：在spring容器里面定义：
    <!--id是这个bean的唯一的标识符（必须唯一），class为对象的位置-->
    <bean id="boy" class="com.offcn.entity.Boy"></bean>
 3：测试
 //如何加载配置文件，参数是你当前配置文件的路径（类路径）
        ApplicationContext app=new ClassPathXmlApplicationContext("appliactionContext.xml");
//得到具体的实体bean，这一个参数传递的就是你的配置文件里的id，这个位置需要强转
        Boy boy= (Boy) app.getBean("boy");
        boy.say();

加载配置文件的三种方式：

//第一种获取类路径加载配置文件（最常用）
       ApplicationContext app=new ClassPathXmlApplicationContext("appliactionContext.xml");

//第二种用全路径的方式来加载配置文件；参数传递的是当前配置文件的全路径
        ApplicationContext app=new FileSystemXmlApplicationContext("C:\\Users\\ibm\\IdeaProjects\\Day1\\src\\appliactionContext.xml");

//第三种方式，用BeanFactory来加载配置文件，参数同样是全路径
        BeanFactory app=new XmlBeanFactory(new FileSystemResource("C:\\Users\\ibm\\IdeaProjects\\Day1\\src\\appliactionContext.xml"));

4.依赖注入(以及几种配置文件加载方式)
（动态的实例化对象，用到的时候，实例化对象）

●创建两个对象
1：Boy.java
public class Boy implements Serializable {
    public  void say(){
        System.out.println("我是一个男孩！");
 }  }
 2:Girl.java
 public class Girl {
    private Boy boy;
	//set 方式注入
    public void setBoy(Boy boy) {
        this.boy = boy;
    }
    //这里调用男孩的方法
    public void kiss(){
    boy.say();
    }
}
●在spring容器里面定义
<!--id是这个bean的唯一的标识符（必须唯一）-->
	<bean id="boy" class="com.offcn.entity.Boy"></bean>
<!--girlBean 在girl对象里要动态注入男孩对象-->
<!--第一个name值，就是set注入的那个属性值；ref拿到的是引入对象的id-->
	<bean id="girl" class="com.offcn.entity.Girl">
	<property name="boy" ref="boy"></property>
	</bean>
●测试
public class Text {
    public static void main(String[] args) {
	//获取类路径加载配置文件
       ApplicationContext app=new ClassPathXmlApplicationContext("appliactionContext.xml");
        Girl girl= (Girl) app.getBean("girl");
        girl.kiss();
    }
}

第一种是实现接口的方式；
第二种是静态工厂的方式；
第三种是用非静态的方式；

5.三种实例化bean的方式（使用p命名空间来进行赋值）

第一种是实现接口的方式；

 <!--配置service的bean，要配置实现层，因为接口不能被实例化-->
 <bean id="userService" class="com.offcn.service.impl.UserServiceImpl"></bean>

第二种是静态工厂的方式；

<!--用静态工厂来实例化对象，factory-method获取静态的方法（不需要括号）-->
<bean id="userObject" class="com.offcn.utils.UserObject" factory-method="creatUserService"></bean>

第三种是实例工厂的方式

 <!--使用非静态的方式;factory-bean代表你实例化对象的id,factory-method引入方法-->
<bean id="userObject" class="com.offcn.utils.UserObject"></bean>
<bean id="user" factory-bean="userObject" factory-method="creatUserService"></bean>

使用p命名空间来进行赋值

	<!--用P命名的方式来给其赋值-->
<bean id="person" class="com.offcn.entity.Person" p:pid="123" p:pname="admin"></bean>
	<!--用spring来给基本属性赋值，这里的name对应的就是属性的名称-->
<bean id="userObject" class="com.offcn.utils.UserObject">
        <!--给对象注入,name值是注入的那个属性值；ref拿到的是引入对象的id-->
<property name="person" ref="person"/></bean>

6.依赖注入 手动装配（set 构造）

//dao层的注解，固定的
@Repository("userDao")
public class UserDaoImpl implements UserDao {
    @Override
    public void add() {
        System.out.println("添加成功");
    }
}
第一种：
@Service("userService")
public class UserServiceImpl implements UserService {
    //service层要注入dao对象
    //代表自动装配，按照类型进行装配
    //按照名称进行装配
	@Autowired
	@Qualifier("userDao")
    private UserDao userDao;
    @Override
    public void add() {
        userDao.add();
    }
}
第二种：
@Service("userService")
public class UserServiceImpl implements UserService {
    //service层要注入dao对象
    //代表自动装配，按照类型进行装配
    @Autowired
    private UserDao userDao;
    //用set方法按照名称来进行装配
    public void setUserDao(@Qualifier("userDao") UserDao userDao) {
        this.userDao = userDao;
    }
    @Override
    public void add() {
        userDao.add();
    }
}
第三种：
@Service("userService")
public class UserServiceImpl implements UserService {
    //service层要注入dao对象
    //代表自动装配，按照类型进行装配
    private UserDao userDao;
    //用构造来按照名称进行装配
    @Autowired
    public UserServiceImpl(@Qualifier("userDao") UserDao userDao) {
        this.userDao = userDao;
    }
    @Override
    public void add() {
        userDao.add();
    }
}
第四种（常用，最简单方式）：
@Service("userService")
public class UserServiceImpl implements UserService {
    //service层要注入dao对象
    //用java的注解来进行装配，jdk按本必须在1.6以上
    @Resource
    private UserDao userDao;
    @Override
    public void add() {
        userDao.add();
    }
}

7.对象，集合，数组的注入，bean的赋值；

●创建工具类
public class UserObject {
    //需求是，给这两个用application来进行赋值
    private int sid;
    private String sname;
    //给对象进行注入
    private Person person;
    //给集合进行注入
    private List<String> list;
    //给set集合进行赋值
    private Set<Object> set;
    //给map进行赋值
    private Map<String, String> map;
    //给数组赋值
    private Object[] objects;

    public void setObjects(Object[] objects) {
        this.objects = objects;
    }

    public void setMap(Map<String, String> map) {
        this.map = map;
    }

    public void setSet(Set<Object> set) {
        this.set = set;
    }

    public void setList(List<String> list) {
        this.list = list;
    }

    public Person getPerson() {
        return person;
    }

    public void setPerson(Person person) {
        this.person = person;
    }

    public void setSid(int sid) {
        this.sid = sid;
    }

    public void setSname(String sname) {
        this.sname = sname;
    }
	//输出的方法
    public void print() {
        System.out.println(this.sid + "\t" + this.sname + "\t" + this.person.getPid() + "\t" + this.person.getPname());
        if (list != null && list.size() > 0) {
            for (Object o : list) {
                System.out.println(o);
            }
        }
        
        //遍历set集合
        Iterator<Object> iterator = set.iterator();
        //判断是否有下一个元素
        while (iterator.hasNext()) {
            Object object = iterator.next();
            System.out.println(object);
        }

        //map的遍历
        Set<String> set1 = map.keySet();
        Iterator<String> iterator2 = set1.iterator();
        //判断是否有下一个元素
        while (iterator2.hasNext()) {
            Object object = iterator2.next();
            System.out.println(object + "\t" + map.get(object));
        }
        
        //数组的遍历
        if (objects !=null && objects.length>0){
            for (int i=0;i<objects.length;i++){
                System.out.println(objects[i]);
            }
        }
    }
}
●不同的赋值方式
    <bean id="userObject" class="com.offcn.utils.UserObject">
    <property name="sid" value="24"/>
    <property name="sname" value="xiaoming"/>
     	   <!--给集合注入值-->
     <property name="list">
            <list>
                <value>admin</value>
                <value>ad</value>
                <value>a</value>
                <value>adm</value>
            </list>
      </property>
    	    <!--给set集合注入值-->
        <property name="set">
            <set>
                <value>儿子</value>
                <value>爸爸</value>
                <value>孙子</value>
            </set>
        </property>
        	  <!--给map集合注入值-->
        <property name="map">
            <map>
                <entry key="01">
                    <value>001</value>
                </entry>
                <entry key="02">
                    <value>002</value>
                </entry>
            </map>
        </property>
          <!--给数组注入值-->
        <property name="objects">
            <array>
                <value>马超</value>
                <value>黄盖</value>
                <value>张飞</value>
            </array>
        </property>
    </bean>
    ●测试