培训第2个月的第2天----Spring框架初识

                  今天主要简单的介绍一下spring框架的ioc。

一.什么是spring框架

                  spring框架创立于2003年，是为了解决企业级开发的复杂性的！是一个分层的一站式轻量级开源的框架。

二.什么是Ioc

                   控制反转模式（也称依赖性介入）的基本概念是：不创建对象，但是描述它们创建的方式。在典型的ioc场景中，容器创建了所有对象，并设置必要的属性将它们联系在一起。

三.代码演示

                 要想使用IOC模式管理对象，先要在applicationContext.xml中配置beans容器。

<?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-3.2.xsd"
       
>
	<bean class="com.java.Bean.User" id="user1"></bean>
	<bean class="com.java.Bean.User" id="user2"></bean>
	
	<!-- 将等量的java代码转换为配置文件代码 -->
	     <!-- 创建数据源   -->
	<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" scope="singleton">
	   <property name="url" value="jdbc:mysql://localhost:3306/ssgl"></property>
	   <property name="username" value="root"></property>
	   <property name="password" value="root"></property>
	   <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
	</bean>
	
	     <!-- 创建操作数据库的模板 -->
	 <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
	   <property name="dataSource" ref="dataSource"></property>
	 </bean>    
	 
	     <!-- 配置Dao依赖 -->
	  <bean class="com.java.Dao.UserDao">
	     <property name="jdbcTemplate" ref="jdbcTemplate"></property>
	  </bean>
</beans> 

                假如我们不用spring框架来管理对象，而是自己用java代码来描述对象间的关系，那么就需要这样写。

package com.java.text;

import java.util.List;
import java.util.Map;

import org.apache.commons.dbcp.BasicDataSource;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.jdbc.core.JdbcTemplate;

import com.java.Bean.User;

public class Text1 {
        public static void main(String[] args) {
        	//加载spring的核心配置文件
         	ApplicationContext classPathXmlApplicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
        	//通过spring核心配置文件来创建对象，而不是用new的方式创建
        	User user1=(User)classPathXmlApplicationContext.getBean("user1",User.class);
        	//输出所得到的User对象
        	System.out.println(user1);
        	
        	//Spring框架内部封装了轻量级的jdbc，通过spring框架就可以进行数据库的查询
        	//创建一个基础数据源对象，用来存放链接数据库的几大属性
        	BasicDataSource basicDataSource=new BasicDataSource();
        	basicDataSource.setUrl("jdbc:mysql://localhost:3306/ssgl");
        	basicDataSource.setUsername("root");
        	basicDataSource.setPassword("root");
        	basicDataSource.setDriverClassName("com.mysql.jdbc.Driver");
        	//打印数据源对象，看看是否链接成功
        	System.out.println(basicDataSource);
        	//创建一个spring框架中自带的jdbc模板，来与数据源进行关联，通过这个模板来操作数据库，或者先创建一个空对象，然后用set方法赋值也可以
        	JdbcTemplate jdbcTemplate = new JdbcTemplate(basicDataSource);
        	List<Map<String, Object>> queryForList = jdbcTemplate.queryForList("select * from t_user");
        	//list集合的每一个元素就对应数据库中的一行，而list中的元素是Map类型的，那么Map集合中的元素就对应中数据库中的每一个单元格
        	//遍历list集合
        	for(Map<String, Object> map:queryForList) {
        		System.out.println(map);
        	}
        	//遍历Map集合,用Map集合可以动态的转载属性
        	for(Map<String, Object> map:queryForList) {
        		for(String key:map.keySet()) {
        			System.out.print(map.get(key)+"--");
        		}
        		    System.out.println();
        	}
        }
}

                    注意，如果我们在spring的核心配置文件中配置了beans，那么我们在写代码的时候就可以通过配置文件来得到对象，而不需要用 new的来创建。在每一个bean标签中，都有一个scope的属性，通过这个属性就可以控制该类的对象是单例的还是多例的。如果将这个属性设置为“singleton”那么这个类的对象就是单例的，这个也是默认值。如果将这个属性设置为“prototype”，那么每创建一个对象都是一个新的对象。

package com.java.text;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.support.rowset.SqlRowSet;

public class Text2 {
    public static void main(String[] args) {
    	//加载spring框架的核心配置文件
    	ApplicationContext applicationContext=new ClassPathXmlApplicationContext("applicationContext.xml");
    	//创建用于操作数据库的模板对象
    	JdbcTemplate jdbcTemplate=applicationContext.getBean(org.springframework.jdbc.core.JdbcTemplate.class);
    	JdbcTemplate jdbcTemplate2=applicationContext.getBean(org.springframework.jdbc.core.JdbcTemplate.class);
    	//验证是否是单例模式,==比较的是对象的地址
    	System.out.println(jdbcTemplate==jdbcTemplate2);
    	//查询数据库
    	SqlRowSet sqlRowSet=jdbcTemplate.queryForRowSet("select * from t_user"); 
    	System.out.println("sqlRowSet:"+sqlRowSet); //sqlRowSet:org.springframework.jdbc.support.rowset.ResultSetWrappingSqlRowSet@1d7acb34
    	while(sqlRowSet.next()) {
    		String userid=sqlRowSet.getString("userid"); //userid" 数据库中的字段名
    		System.out.println("userid:"+userid);
    	}
    }
}

                      通常，我们为了简化代码，只需要创建一个Dao，这个Dao中包含操作数据库的jdbcTemplate对象和方法，只需要创建一个该类的对象和调用方法就能操作数据库。

package com.java.Dao;

import java.util.List;
import java.util.Map;

import org.springframework.jdbc.core.JdbcTemplate;

public class UserDao {
       private JdbcTemplate jdbcTemplate;
       public void setJdbcTemplate(JdbcTemplate jdbcTemplate){
    	   this.jdbcTemplate=jdbcTemplate;
       }
       //一些简单的查询方法
       public List<Map<String, Object>> get_user() {
        List<Map<String, Object>> queryForList = jdbcTemplate.queryForList("select * from t_user");
    	return queryForList;
       }
       
       public Map<String,Object> get_userById(String userid,String username) {
    	  Object[] obj= {userid,username};
    	  // queryForMap()方法有3种重载，要注意 ，要确定参数类型时要Type.类型。int[] 能代表参数类型
    	  Map<String,Object> map = jdbcTemplate.queryForMap("select * from t_user where userid=? and username=?",obj);
    	  return map;
    	
       }
}

              定义一个测试类来验证代码。也让我们回顾一下Map集合的遍历方式。

package com.java.text;

import java.util.List;
import java.util.Map;

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

import com.java.Dao.UserDao;

public class Text3 {
	//从ioc容器中获取userDao的对象，一层一层的给
	ApplicationContext applicationContext=new ClassPathXmlApplicationContext("applicationContext.xml");
	UserDao userDao = (UserDao)applicationContext.getBean(UserDao.class);
	//调用方法来获得user数据
    public static void main(String[] args) {
    	Text3 text3=new Text3();
    	//text3.get_user();
    	text3.get_userById("21", "qiaoyaya");
    }
    
    public void get_user() {
    	List<Map<String, Object>> list = userDao.get_user();
    	for(Map<String, Object> map:list) {
    		for(String key:map.keySet()) {
    			System.out.print(map.get(key)+"--");
    		}
    		System.out.println();
    	}
    }
    
    public void get_userById(String userid,String username) {
    	Map<String, Object> map = userDao.get_userById(userid, username);
    	for(String key:map.keySet()) {
    		System.out.print(map.get(key)+"--");
    	}
    }
}

               IoC（Inversion of Control​，控制反转）也称为依赖注入（Dependency Injection），作为Spring的一个核心思想，是一种设计对象之间依赖关系的原则及其相关技术。