Spring5——（一）spingIOC（入门介绍，spring创建bean，依赖，注入，注解方式）

为什么要有框架？

（1）对于web层来说，一个大型的程序往往需要编写大量的servlet，并且取值封装会非常繁琐。
（2）对于dao层，要编写大量的sql语句，对于结果的解析也很麻烦，并且sql的复用性很差。
（3）web，service，dao三层之间的依赖较大，导致代码的扩展性低。
（4）会编写大量重复的代码，开发效率大打折扣。
主要的框架有SSH（Strus，Spring，Hibernate）不太用，SSM（Spring，SpringMVC，MyBaties），SpringBoot，SpringCloud。

Spring框架

Spring介绍
**Spring是一个开源的控制反转和面向切面的容器框架。**控制反转和面向切面是Spring框架的核心，Spring家族的后续产品都是建立在这个基础上的。
Spring框架的优点
- spring是一个容器框架，默认提供单例模式。
- 减低程序中组件的依赖关系，解耦。
- spring中的AOP更容易实现面向切面编程。
- spring可以非常轻松的和其他主流框架相集成。

一、spingIOC/DI

//业务逻辑层代码
public class UserService{//调用dao，创建dao的对象private UserDao userDao=new UserDao();public void userRegister(User user){         }
}
//数据库访问层代码
public class UserDao{public User queryByLoginName(String name){}public void save(User  user){}
}

上面的代码中UserDao类的对象是由程序员自己创建的，可以吧创建对象的任务交给Spring框架来完成，这就是DI(控制反转)。

//业务逻辑层代码
public class UserService{//调用dao，创建dao的对象private UserDao userDao;public void setUserDao(UserDao userDao){this.userDao=userDao;}     public void userRegister(User user){//userDao.任何方法或者属性均会空指针 }
}

上面的代码中并没有手动创建对象，而是通过set方法来传入一个对象，而通过spring将对象创建好之后再将对象传入就叫IOC(依赖注入)。

1、spring入门

（1）打入jar包

<dependency><groupId>org.springframework</groupId><artifactId>spring-context</artifactId><version>5.1.9.RELEASE</version>
</dependency>

（2）创建applicationContext.xml配置文件并编写bean

applicationContext.xml是spring容器核心配置文件，在此文件中目前主要配置javabean，配置javabean就是将javabean交给spring容器进行管理。

<?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/beanshttp://www.springframework.org/schema/beans/spring-beans.xsd"><!-- id是spring中bean的唯一标识,在程序中可以通过id获取bean对象--><!-- class是类的全路径,此类必须严格遵守javabean的规范,也就是需要有一个无参的构造方法,spring会通过类的全路径字符串构建类对象--><!-- scope可以设置bean的管理方式 默认是单例singleton prototype是原型模式,每次都是新的对象bean管理方式的单子/单例默认值 --><bean id="ioCtest" class="com.spring.service.IOCtest" scope="prototype"></bean>
</beans>

（3）测试

package com.spring.test;
import com.spring.service.IOCtest;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class test2 {@Testpublic void IOC(){//ClassPathXmlApplicationContext从类路径下加载配置文件ApplicationContext applicationContext=new ClassPathXmlApplicationContext("applicationContext.xml");IOCtest ioCtest = applicationContext.getBean("ioCtest", IOCtest.class);System.out.println(ioCtest == ioCtest1);//false//调用类IOCtest中的方法ioCtest.IOC();}
}

2、spring创建bean的三种方式

（1）构造方法实例化（常用）

spring容器默认会创建javabean对象，在容器初始化的时候，一定是用反射调用类的无参数构造方法。

（2）静态工厂方法

构造是私有的，我们可以再类的外部访问类的私有属性。

<bean id="runtime" class="java.lang.Runtime" factory-method="getRuntime" />

（3）实例方法创建

一个工厂类提供一个工厂方法

<bean id="demo2Factory" class="com.spring.service.Demo2Factory"></bean><!--前面已经将对象创建好了--><bean id="fact" factory-method="demo" factory-bean="demo2Factory"></bean>

3、bean的依赖

package com.spring.dao;
public class IUserDaoImpl implements IUserDao {@Overridepublic void checkName() {System.out.println("检验姓名");}@Overridepublic void saveUser() {System.out.println("注册");}
}

（1）用set方法进行注入

package com.spring.service;
import com.spring.dao.IUserDaoImpl;
public class SaveUserService {private IUserDaoImpl userDao;//第一种情况 set方式注入public void setUserDao(IUserDaoImpl userDao) {this.userDao = userDao;}public void usersave() {userDao.saveUser();userDao.checkName();System.out.println("set方式注入");}
}

<bean id="IUserDao" class="com.spring.dao.IUserDaoImpl"></bean>
<bean id="SaveUserService" class="com.spring.service.SaveUserService"><property name="userDao" ref="IUserDao"/>
</bean>

（2）使用构造方法进行注入

package com.spring.service;
import com.spring.dao.IUserDaoImpl;
public class SaveUserService1 {private IUserDaoImpl userDao;//有参构造注入public SaveUserService1(IUserDaoImpl userDao){this.userDao=userDao;}public void saveuser(){userDao.saveUser();userDao.checkName();System.out.println("有参构造注入");}
}

<bean id="IUserDao" class="com.spring.dao.IUserDaoImpl"></bean>
<bean id="SaveUserService1" class="com.spring.service.SaveUserService1"><constructor-arg ref="IUserDao"/>
</bean>

4、属性注入

（1）简单数据类型

package com.spring.service;
import java.util.List;
import java.util.Map;
/*
* 基本属性的注入
* */
public class demo1 {private int age;private String name;private List<String> list;private Map<Integer,String> map;public void setAge(int age) {this.age = age;}public void setName(String name) {this.name = name;}public void setList(List<String> list) {this.list = list;}public void setMap(Map<Integer, String> map) {this.map = map;}@Overridepublic String toString() {return "demo1{" +"age=" + age +", name='" + name + '\'' +", list=" + list +", map=" + map +'}';}
}

<bean id="demo1" class="com.spring.service.demo1"><property name="age" value="19"></property><property name="name" value="张三"></property><property name="list"><list><value>张三</value><value>李四</value><value>yjd123</value></list></property><property name="map"><map><entry key="001" value="凄凄切切"></entry><entry key="002" value="得到"></entry></map></property></bean>

（2）properties配置文件

properties数据类型的注入

package com.spring.service;
import java.util.Properties;
public class ProperDemo {private Properties properties;public void setProperties(Properties properties) {this.properties = properties;}public Properties getProperties() {return properties;}
}

<!-- 方式1--><property name="properties"><value>driverClassName=com.mysql.jdbc.Driverurl=jdbc:mysql://localhost/mydenousername=rootpassword=123456</value>
</property>
<!--方式2--><bean id="properDemo" class="com.spring.service.ProperDemo"><property name="properties"><props><prop key="driverClassName">com.mysql.jdbc.Driver</prop><prop key="url">jdbc:mysql://localhost/mydeno</prop></props></property>
</bean>

独立的properties文件

package com.spring.service;
public class jdbcdemo {private String driverClassName;private String url;private String username;private String password;public void setDriverClassName(String driverClassName) {this.driverClassName = driverClassName;}public void setUrl(String url) {this.url = url;}public void setUsername(String username) {this.username = username;}public void setPassword(String password) {this.password = password;}@Overridepublic String toString() {return "jdbcdemo{" +"driverClassName='" + driverClassName + '\'' +", url='" + url + '\'' +", username='" + username + '\'' +", password='" + password + '\'' +'}';}
}

<!--spring提供的专门用于读取properties文件的bean--><bean id="factoryBean" class="org.springframework.beans.factory.config.PropertiesFactoryBean"><property name="locations"><array><value>classpath:jdbc.properties</value></array></property></bean><bean id="jdbcdemo" class="com.spring.service.jdbcdemo"><property name="driverClassName" value="#{factoryBean.driverClassName}"></property><property name="url" value="#{factoryBean.url}"></property><property name="username" value="#{factoryBean.username}"></property><property name="password" value="#{factoryBean.password}"></property></bean>

5、bean的自动装配

 <!--自动注入--><bean id="IAccountDao" class="com.spring.dao.AccountFileDao"></bean><!--autowire-candidate="false"表示该bean不参与自动装配--><bean id="accountSqlDao" class="com.spring.dao.AccountSqlDao" autowire-candidate="false"></bean><!--autowire="byType"是按照类型进行注入--><!--autowire="byName" AccountService中的setXXXX和对应的bean中的id中的相匹配--><!--autowire="constructor" 通过构造方法进行注入--><bean id="accountService" class="com.spring.service.AccountService" autowire="constructor"></bean>

6、注解方式实现之前的功能

配置注解解析器组件

<!--告知spring扫描包--><!--并对注解进行解析--><!--spring会扫描当前包以及子包-->
<context:component-scan base-package="com.oracle" />

（1）把bean交给spring容器

//有四种注解,本质上都是一样的，都可以将bean交给spring容器
@Component-组件
@Service- 业务逻辑
@Repository- 数据库储存dao
@Controller-控制servlet,springMVC的时候使用

package com.spring.service;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Repository;
import org.springframework.stereotype.Service;
/*这两个注解本质都是一样的，都可以将bean交给spring容器，并且可以设置指定的beanid*/
@Service("awdaw") //设置id //@Repository()//一般用于dao层 数据库层
/*里面填默认值 id是类名的驼峰命名法 首字母小写*/
@Scope("prototype")              //设置单例/原型模式
public class Annotion {public void etts(){System.out.println("将bean交给spring容器的注解");}
}

测试

 @Testpublic void test1(){ApplicationContext applicationContext =new ClassPathXmlApplicationContext("applicationContext.xml");Annotion awdaw = applicationContext.getBean("awdaw", Annotion.class);/*  Annotion awdaw1 = applicationContext.getBean("annotion", Annotion.class);*/awdaw.etts();}

（2）bean的注入

spring提供

@Autowired默认是按照byType方式
@Qualifier不能单独使用,需要结合Autowired配合使用

package com.spring.dao;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Repository;
@Repository("dao1")
public class IUserDaoImpl implements IUserDao {public void save() {System.out.println("注解");}
}

package com.spring.service;
import com.spring.dao.IUserDao;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Repository;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;/*
* 注入注解spring提供了两种
* */
@Service
public class UserService {/*一共有三种注解来进行注入*/@Autowired()  //用的最多   //第一种方式 默认是按照类型进行注入 当有两个以上的类型时 会报错@Qualifier("dao2")    //第二种方式 通过这个可以指定名字来确定是哪个 不能单独使用一般和Autowired结合来使用//@Resource(name = "dao1")      //第三种方式 javaEE提供的 可以按照类型 也可以按照idprivate IUserDao iUserDao;/*这里不能使用username会和电脑的用户名冲突*/@Value("${driverClassName}")private String name;public void demo(){iUserDao.save();System.out.println(name);}
}

测试

 @Testpublic void test2(){ApplicationContext applicationContext =new ClassPathXmlApplicationContext("applicationContext.xml");UserService userService = applicationContext.getBean("userService", UserService.class);userService.demo();}

（3）纯java配置方式（不使用applicationContext配置文件）

package com.spring.service;import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;import java.util.Date;/*
*使用ApplicationConfig类代替applicationContext.xml配置文件
* @ComponentScan替代扫描
*
* */
@Configuration
@ComponentScan("com.spring")
@PropertySource("jdbc.properties")/*替代属性文件的加载*/
public class ApplicationConfig {@Bean("springDate")public Date createDate(){return new Date();}
}

测试

 @Testpublic void test3(){AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(ApplicationConfig.class);UserService userService = context.getBean("userService", UserService.class);userService.demo();}@Testpublic void test4(){AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(ApplicationConfig.class);Date date = context.getBean("springDate", Date.class);System.out.println(new SimpleDateFormat("yyyy-mm-dd hh:mm:ss").format(date));}