Spring 学习

1、spring

1.1、简介

spring理念：使现有的技术更加容易使用，本身是一个大杂烩，整合了现有的技术框架。

<!-- maven对spring的依赖 -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>5.2.1.RELEASE</version>
</dependency>
<!-- spring对于mybatis的整合 -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-jdbc</artifactId>
    <version>5.2.1.RELEASE</version>
</dependency>

1.2、优点及拓展

spring是一个开源的免费框架（容器）。
spring是一个轻量级的、非入侵式的框架。
控制反转（IOC），面向切面编程（AOP）。
支持事务的控制，对框架整合的支持。

Spring Boot

一个快速开发的脚手架。
基于Spring Boot可以快速的开发单个微服务。
预定大于配置

Spring Cloud

Spring Cloud是基于Spring Boot实现的。

1.3、IOC理论推导

传统模式：程序是主动创建，控制权在程序员手上。

	//service层
	private UserDao userDao; 

	@Override
	public void getUser() {
		userDao = new UserDaoImpl();
		userDao.getUser();
	}

	//main方法
	public static void main(String[] args) {
		UserService userService = new UserServiceImpl();
		userService.getUser();
	}

2.IOC原型：使用了set注入后，程序不再具有主动性，而是变成了被动的接受对象。

	//service层
	private UserDao userDao;

	//利用set进行动态实现值得注入
	public void setUserDao(UserDao userDao) {
		this.userDao = userDao;
	}

	@Override
	public void getUser() {
		userDao.getUser();
	}

//main方法
public static void main(String[] args) {
    UserService userService = new UserServiceImpl();
    //利用set方法，把接 口的实现类让用户选择，实现控制反转
    userService.setUserDao(new UserDaoImpl());

    userService.getUser();
    }

这种思想，从本质上解决了问题，我们程序员不用再去管理对象的创建。系统的耦合性大大降低，可以更加专注在业务的实现上！这就是IOC的原型。

控制反转是一种通过描述（XML或注解）并通过第三方去生产或获取特定对象的方式。在Spring中实现控制反转的是IOC容器，其实现方式是依赖注入（Dependency Injetion，DI）

1.4、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"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd">

    <!--  使用Spring来创建对象,在Spring这些都称为bean 
	等同于： UserDao userDao = new UserDaoImpl();
	      id : 变量名          
	      class : new的对象
	      property : 相当于给对象中的属性赋值
    -->
    <bean id="userDao" class="com.chengchao11.dao.UserDaoImpl">
    </bean>
    
    <!-- 
	     ref : 引用Spring容器中创建好的对象
	     value : 具体的值,基本数据类型
    -->
    <bean id="userService" class="com.chengchao11.service.UserServiceImpl">
        <property name="userDao" ref="userDao"/>
        <property name="name" value="chengchao002"/>
    </bean>
</beans>

public static void main(String[] args) {
	//获取Spring的上下文对象，对象在这一步被创建！
	ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
	//我们的对象现在都再Spring中管理了，我们要使用，直接去里面取！
	UserService userService = (UserService) context.getBean("userService");
	userService.getUser();
}

到现在，我们彻底不用在程序中去改动了，要实现不同的操作，只需要在xml配置文件中进行修改，所谓的IOC就是：对象由Spring来创建，管理，装配！

1.4.1 IOC容器创建对象的方式

public class UserServiceImpl implements UserService {
	
	private String name;
	
	private UserDao userDao;
	
	public UserServiceImpl() {
		System.out.println("调用UserService 无参构造器");
	}
	
	public UserServiceImpl(String name) {
		this.name = name;
		System.out.println("调用UserService 有参构造器name被赋值为:"+this.name);
	}
	
	public void setName(String name) {
		this.name = name;
		System.out.println("调用setName方法,name被赋值为:"+this.name);
	}
	
	public void setUserDao(UserDao userDao) {
		this.userDao = userDao;
		System.out.println("调用setUserDao方法");
	}

	@Override
	public void getUser() {
		userDao.getUser();
		System.out.println("UserServiceImpl.name:"+name);
	}
}

//控制台输出:
调用UserService 无参构造器
调用setUserDao方法
调用setName方法,name被赋值为:chengchao002
默认获取用户的数据！
UserServiceImpl.name:chengchao002

使用set方法给对象属性赋值！
使用无参构造器创建对象，默认！

假设我们要使用有参构造创建对象（三种方式）。

<!--第一种，下标赋值！-->
<bean id="userService" class="com.chengchao11.service.UserServiceImpl">
   <constructor-arg index="0" value="chengchao001"/>
   <property name="userDao" ref="userDao"/>
   <property name="name" value="chengchao002"/>
</bean>

<!--第二种，通过类型赋值，不建议使用！-->
<bean id="userService" class="com.chengchao11.service.UserServiceImpl">
   <constructor-arg type="java.lang.String" value="chengchao001"/>
   <property name="userDao" ref="userDao"/>
   <property name="name" value="chengchao002"/>
</bean>

<!--第三种，直接通过参数名来设置！-->
<bean id="userService" class="com.chengchao11.service.UserServiceImpl">
   <constructor-arg name="name" value="chengchao001"/>
   <property name="userDao" ref="userDao"/>
   <property name="name" value="chengchao002"/>
</bean>

//控制台输出:
调用UserService 有参构造器，name被赋值为:chengchao001
调用setUserDao方法
调用setName方法，name被赋值为:chengchao002
默认获取用户的数据！
UserServiceImpl.name:chengchao002

1.4.2 Bean的自动装配

自动装配是Spring满足bean依赖的一种方式！
Spring会在上下文中自动寻找，并自动给bean装配属性！

在Spring中有两种自动装配的方式

<!-- 
    byName:会自动在容器上下文中查找，和自己对象set方法后面的值对应的beanid！
-->
<bean id="userService" class="com.chengchao11.service.UserServiceImpl" autowire="byName">
</bean>

<!-- 
    byType:会自动在容器上下文中查找，和自己对象属性相同的beanid！
-->
<bean id="userService" class="com.chengchao11.service.UserServiceImpl" autowire="byType">
</bean>

1.5、Annotation实现方式

jdk1.5支持的注解，Spring2.5就支持注解了！

要使用注解须知：

导入约束：context约束
配置注解的支持：context:annotation-config/

<?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
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        https://www.springframework.org/schema/context/spring-context.xsd">
	
    <!--注解的驱动！-->
    <context:annotation-config/>

</beans>

1.5.1 注解实现自动装配

@Autowired

自动装配，直接在属性上使用即可！也可以在set方法上使用

使用@Autowired我们可以不用编写set方法了，前提是你这个自动装配的属性在 IOC 相同类型的bean。

@Qualifier

如果@Autowired 自动装配的环境比较复杂，自动装配无法通过一个注解完成的时候，我们可以使用

@Qualifier去配合@Autowired的使用，指定一个唯一的bean对象注入！

@Autowired 和 @Resource的区别：

都是用来实现自装配的，都可以放在属性字段上。
@Autowired 是由Spring提供的注解，@Resource是由java提供的注解。
@Autowired 通过byType的方式实现，而且必须要求这个对象存在。
@Resource 默认通过byName的方式实现，如果找不到名字，则通过byType实现，如果两个都找不到的情况下，就报错。

1.5.2 组件扫描

要使用组件扫描需要指定扫描的包。

注：context:component-scan包含了context:annotation-config，不需要重复添加注解驱动。

<?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
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        https://www.springframework.org/schema/context/spring-context.xsd">

    <!--指定要扫描的包！这个包下的注解就会生效-->
    <context:component-scan base-package="com.chengchao22"></context:component-scan>
    
</beans>

//@Component 定义组件
//等价于 <bean id="people" class="com.chengchao22.vo.People/">
@Component
public class People {
   
   //@Value 属性值的注入
   //相当于 <property name="name" value="程超">
   @Value("chengchao11")
   private String name;
	
	@Autowired
	private Cat cat;
	
	@Autowired
	private Dog dog;

	public Cat getCat1() {
		return cat;
	}

	public Dog getDog() {
		return dog;
	}
}

@Component：放在类上定义组件，说明这个类被Spring管理了，也就是bean！

通常按照mvc三层架构有几个衍生的注解：

@Repository：定义dao层的组件。

@Service：定义serbvice层的组件。

@controller：定义controller层的组件。

这四个注解功能都是一样的，都是代表将某个类注册到Spring中，装配bean。

posted @ 2020-03-30 21:21 Epiphany1995 阅读(68) 评论(0) 收藏举报

刷新页面返回顶部

Epiphany1995