Spring第一天
一、Spring简介
1. 概念
Spring是一个轻量级的控制反转和面向切面编程的框架
2. 优点
1. 是一个开源、免费的框架
2. 是一个轻量级、非入侵式的框架(只需要导入包)(导了之后对原项目不会有影响)
3. 控制反转、面向切面编程
4. 支持事务的处理,对框架整合的支持
二、Spring组成
1.七大模块
2.三大思想
三、ioc思想
1. 原本:
UserMapper
public interface UserMapper
{
public void selUser();
}
UserMapperImpl
public class UserMapperImp implements UserMapper
{
@Override
public void selUser()
{
System.out.println("已找到用户");
}
}
UserService
public interface UserService
{
public void selUserService();
}
UserServiceImpl
public class UserServiceImpl implements UserService
{
@Override
public void selUserService()
{
UserMapper userMapper = new UserMapperImp();
userMapper.selUser();
}
}
2. 问题:
此时,若有新的Mapper实现类,在Service实现类中,需要改代码,将
UserMapper userMapper = new UserMapperImp()
改为新的
UserMapper userMapper = new UserMapperImpl2();
3. 解决办法:
用set方法,在ServiceImpl中不要写死,让用户去传参数
public class UserServiceImpl implements UserService
{
private UserMapper userMapper;
public void setUserMapper(UserMapper userMapper)
{
this.userMapper=userMapper;
}
@Override
public void selUserService()
{
userMapper.selUser();
}
}
public class TestA
{
public static void main(String[] args)
{
UserService userService=new UserServiceImpl();
userService.setUserMapper(new UserMapperImpl2());
userService.selUserService();
}
}
4. 思想:
原本,程序是在ServiceImpl中主动去创建Mapper对象,控制权在程序员手上
现在,用了set注入,程序员不再有主动性,而是变成了被动的接收对象
增加类的时候,只需要增加类,其他代码无需改变,由用户去改变选择
从本质上解决了问题,程序员不用去管理对象的创建,系统的耦合性大大降低,更加专注在业务的实现上
这就是ioc的原型,控制反转,控制权由程序员变为用户
四、HelloSpring
1. 导包
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>5.3.9</version>
</dependency>
2. Hello类
public class Hello
{
private String str;
public Hello() {
}
public String getStr() {
return str;
}
public void setStr(String str) {
this.str = str;
}
@Override
public String toString() {
return "Hello{" +
"str='" + str + '\'' +
'}';
}
}
3. beans.xml
<bean id="hello" class="com.xk.pojo.Hello">
<property name="str" value="HelloSpring"></property>
</bean>
4. 实例化容器
//实例化容器
ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
5. 取bean
//取bean
Hello hello = context.getBean("hello", Hello.class);
6. 测试
五、ioc创建对象的方式
package com.xk.pojo;
public class User
{
private int id;
private String name;
public User() {
}
public User(int id) {
this.id = id;
}
public User(String name) {
this.name = name;
}
public User(int id, String name) {
this.id = id;
this.name = name;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "User{" +
"id=" + id +
", name='" + name + '\'' +
'}';
}
}
1.无参构造器
<!--通过无参构造创建对象-->
<bean id="user1" class="com.xk.pojo.User">
</bean>
//获取spring容器
ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
//获得bean
User user1 = context.getBean("user1", User.class);
//测试
System.out.println(user1);
2.有参构造器
① 通过下标赋值
<!--通过下标赋值-->
<bean id="user" class="com.xk.pojo.User">
<constructor-arg index="0" value="1"/>
</bean>
② 通过类型创建
<!--通过类型创建-->
<bean id="user" class="com.xk.pojo.User">
<constructor-arg type="int" value="1"></constructor-arg>
<constructor-arg type="java.lang.String" value="xk"></constructor-arg>
</bean>
③ 通过属性名
<!--通过属性名-->
<bean id="user" class="com.xk.pojo.User">
<constructor-arg name="id" value="2"></constructor-arg>
<constructor-arg name="name" value="xk"></constructor-arg>
</bean>
六、Spring配置
1. 别名
name:原id
alias:别名
<alias name="hello" alias="hello2"></alias>
2. bean
3. import
一般用于团队开发使用
把配置文件都导到一个中,比如说都导到A.xml中,程序只读取A,就能获得其他里面的bean
<import resource="B.xml"></import>
七、依赖注入DI
依赖:bean对象的创建依赖于容器
注入:bean对象中的所有属性,由容器来注入
1. 构造器注入
2. set方式注入
1. 普通值注入
2. Bean注入
3. 数组注入
4. List注入
5. Map注入
6. Set注入
7. null值注入
8. Properties注入
<bean id="user" class="com.xk.pojo.User">
<property name="id" value="1"></property>
<property name="name" value="xk"></property>
<property name="teacher" ref="teacher"></property>
<property name="books">
<array>
<value>红楼梦</value>
<value>三国演义</value>
</array>
</property>
<property name="friends">
<list>
<value>nc</value>
<value>ym</value>
</list>
</property>
<property name="sisters">
<map>
<entry key="1" value="大姐"></entry>
<entry key="2" value="二姐"></entry>
</map>
</property>
<property name="clothes">
<set>
<value>短袖</value>
</set>
</property>
<property name="pro">
<props>
<prop key="1">111</prop>
</props>
</property>
</bean>
<bean id="teacher" class="com.xk.pojo.Teacher">
<property name="id" value="1"></property>
<property name="name" value="kk"></property>
</bean>
3. 其他方式注入
八、Bean的作用域
默认为单例,即获取多个bean,但在spring容器中只有一个实例
1. 单例
2. 原型(多例)
每次从容器中getBean时,都会产生一个新的实例
九、Bean的自动装配
自动装配是Spring满足bean依赖的一种方式,Spring会在上下文中自动寻找,并自动给bean装配属性
Spring中的三种装配方式
1. 在xml显示配置(上面的都是)
2. 在java中显示配置
3. 隐式的自动装配bean
使用注解实现自动装配
步骤
1. 导入约束
2. 配置注解的支持
注解
@Autowired
直接在属性上用即可,用了不需要set方法
前提:自动装配的属性在Spring容器中存在,且符合名字Byname,即id和属性名相等
十、使用注解开发
步骤
1. 导入context约束
2. 配置注解的支持
3. 指定要扫描的包,该包下的注解就会生效
分类
1. Bean
@Component 在类上,相当于配了bean
2. 属性
@Value(" ") 在属性上或在set方法上,相当于配了属性值
衍生注解
@Component有几个衍生注解
在web开发中,会用MVC三层架构
1. DAO
@Repository
2. Service
@Service
3. Controller
@Controller
作用域
1. 单例
@Scope("singleton")
2. 多例
@Scope("prototype")
十一、XML与注解
比较
XML,更加万能,适用于任何场景,维护更加简单
注解,不是自己的类用不了,维护比较复杂
实践
XML用来管理bean
注解只用来完成属性的注入