avatar
文章
92
标签
37
分类
14
首页
时间轴
标签
分类
郝永亮的主页
首页
时间轴
标签
分类
Spring01入门和配置信息
|框架
阅读量:

Spring01入门

Spring是什么

Spring是一个轻量级的全栈式框架

轻量级指的是配置方便、占用资源小

全栈式指的是针对controller(springmvc),service(spring),dao(jdbctemplate)有不同的解决方案

Spring发展史

作者：Rod Johnson(Spring之父)

当前最新版：2017年9月发布了Spring 5.0最新通用版。

Spring的两大核心

IOC：全称Inverse of Control,控制反转的意思，表示把对象的创建交给框架

AOP：全称Aspect Oriented Programming,面向切面编程的意思，是对动态代理的再次封装

Spring的优势

1.可以借助IOC降低程序之间的耦合

2.可以借助AOP来实现方法的动态增强

3.支持声明式事物

4.方便集成其他框架,比如struts,hibernate,mybatis等

Spring开发简单原理

1

Spring 开发步骤

导入maven坐标

1
2
3
4
5
6
7
<dependencies>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.0.5.RELEASE</version>
    </dependency>
</dependencies>

编写UserDao接口和实现类

编写UserDao接口

1
2
3
public interface UserDao {
    void save();
}

编写UserDaoImpl实现类

1
2
3
4
5
public class UserDaoImpl implements UserDao {
    public void save() {
        System.out.println("UserDao save method running...");
    }
}

创建Spring配置文件

根据下图步骤创建配置文件，配置文件名字最好叫applicationContext.xml

2

配置文件内容

1
2
3
4
5
6
<?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.xsd">

</beans>

在配置文件中配置bean标签,将对象的创建交给Spring容器

在applicationContext.xml中添加

该标签的作用表示创建一个UserDaoImpl对象，对象名叫userDao

1
2
3
4
5
6
7
8
<?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.xsd">
    
    <bean id="userDao" class="cn.itcast.dao.impl.UserDaoImpl"></bean>

</beans>

使用Spring的API从容器中获取Bean实例

1
2
3
4
5
6
7
8
public class UserDaoImplTest {
    @Test
    public void save() {
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserDao userDao = (UserDao)context.getBean("userDao");
        userDao.save();
    }
}

Spring配置文件详解

bean标签

功能

用于配置对象交由Spring 来创建。

注意事项

1.默认情况下它调用的是类中的无参构造函数，如果没有无参构造函数则不能创建成功。所以建议所有类提供无参构造
2.id值不能重复

基本属性

属性 描述
id Bean实例在Spring容器中的唯一标识
class Bean的全类名
scope singleton: 单例。表示每次调用getBean(“”)方法获取到的都是同一个对象。
prototype:多例。表示每次调用getBean(“”)方法获取到的都是一个新的对象，每次获取到的都不一样

生命周期属性

属性 描述
init-method 创建bean的时候执行该属性指定的方法名
destroy-method 销毁bean的时候执行该属性指定的方法名

在java代码中添加initMethod和destroyMethod

1
2
3
4
5
6
7
8
9
10
11
12

public class UserDaoImpl implements UserDao {
    public void initMethod(){
        System.out.println("对象初始化中");
    }
    public void destroyMethod(){
        System.out.println("对象被干掉了");
    }
    public void save() {
        System.out.println("UserDao save method running...");
    }
}

在配置信息中init-method,destroy-method

1
2
3
4
5
6
<?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.xsd">
    <bean id="userDao" class="cn.itcast.dao.impl.UserDaoImpl" init-method="initMethod" destroy-method="destroyMethod"></bean>
</beans>

测试类

1
2
3
4
5
6
7
8
9
10
11

public class UserDaoImplTest {

    @Test
    public void save() {
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserDao userDao1 = (UserDao)context.getBean("userDao");
        context.close();

    }
}

执行结果

29

创建相关属性

创建方式 描述
无参构造方法实例化
总结:相当于 UserDao userDao = new UserDaoImpl();
方工厂静态方法实例化 第一步:创建静态工厂

第二步：配置class属性指定工厂类，factory-method指定工厂方法

总结：相当于UserDao userDao = StaticFactory.getUserDao();
工厂实例方法实例化 第一步：创建工厂类

第二步：先将工厂类通过bean对象配置到XML中

第三步：配置userDao，通过factory-method指定具体工厂，通过factory-method指定工厂的具体方法

总结：相当于UserDao userDao = new DynamicFactory().getUserDao();

依赖注入(DI)

概念:通过框架给成员变量赋值，有2种方式，set方法和构造方法

通过set方法进行

解释：会调用userDao属性对应的setUserDao方法将id=”userDao”的bean注入给userDao属性

第一种 通过property标签

第二种 通过p命名空间

通过构造方法注入

解释：会调用UserServiceImpl类的的UserServiceImpl(UserDao userDao)方法将id=”userDao”的bean注入给userDao属性

普通数据类型注入

java代码

1
2
3
4
5
6
7
@NoArgsConstructor
@AllArgsConstructor
@Data
public class User {
    private String name;
    private Integer age;
}

通过spring的依赖注入给name和age赋值

1
2
3
4
<bean id="user" class="cn.itcast.domain.User">
	<property name="name" value="孙凯"></property>
	<property name="age" value="22"></property>
</bean>

集合数据类型

java代码

1
2
3
4
5
6
7
8
9
10
11
12
@NoArgsConstructor
@AllArgsConstructor
@Data
public class User {
    private String name;
    private Integer age;
    private List<String> hobbies;//爱好
    private Map<String,String> kids; //孩子
    private Properties wife;//妻子
    private Set<String> grandson;//孙子
    private int[] numbers;//数字
}

通过spring的依赖注入给集合属性赋值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
<bean id="user" class="cn.itcast.domain.User">
    <property name="name" value="孙凯"></property>
    <property name="age" value="22"></property>
    <!-- private List<String> hobbies;//爱好 -->
    <property name="hobbies">
        <list>
            <value>抢红包</value>
            <value>收红包</value>
            <value>放炮</value>
            <value>洗脚</value>
        </list>
    </property>

    <!-- private Map<String,String> kids; //孩子 -->
    <property name="kids">
        <map>
            <entry key="大闺女" value="孙尚香"></entry>
            <entry key="二闺女" value="孙小香"></entry>
            <entry key="三儿子" value="孙悟空"></entry>
        </map>
    </property>

    <!-- private Properties wife;//妻子 -->
    <property name="wife">
        <props>
            <prop key="少奶奶">王晶</prop>
            <prop key="二姨太">张家晨</prop>
            <prop key="三姨太">张子祎</prop>
        </props>
    </property>

    <!-- private Set<String> grandson;//孙子 -->
    <property name="grandson">
        <set>
            <value>孙富贵</value>
            <value>孙可爱</value>
            <value>孙漂亮</value>
            <value>孙美丽</value>
        </set>
    </property>
    
    <!-- private int[] numbers;//数字 -->
    <property name="numbers">
        <array>
            <value>123456</value>
            <value>66666</value>
        </array>
    </property>

</bean>

测试代码

1
2
3
4
5
6
7
8
9
public class UserTest {

    @Test
    public void testx(){
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        Object user = context.getBean("user");
        System.out.println(user);
    }
}

运行结果

1
User(name=孙凯, age=22, hobbies=[抢红包, 收红包, 放炮, 洗脚], kids={大闺女=孙尚香, 二闺女=孙小香, 三儿子=孙悟空}, wife={三姨太=张子祎, 少奶奶=王晶, 二姨太=张家晨}, grandson=[孙富贵, 孙可爱, 孙漂亮, 孙美丽])

注意事项

property容易混淆的2个属性名 value ,ref 都是给属性设置值的，value设置的是普通类型的值，ref是把当前容器中的其他bean赋值给属性

import标签

功能

引入其他xml配置文件

注意事项

该标签和bean是兄弟关系，不是嵌套关系

代码

1
2
3
4
5
6
7
8
9
<?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.xsd">
    <bean id="userDao" class="cn.itcast.dao.impl.UserDaoImpl"></bean>
    
    <import resource="applicationContext-user.xml"></import>
    <import resource="applicationContext-product.xml"/>
</beans>

Spring相关API

ApplicationContext的实现类

ClassPathXmlApplicationContext

从类的根路径下加载配置文件，推荐使用

类的跟路径片面理解指的是src或者resources目录

1
2
//从src目录下加载配置文件
ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");

FileSystemXmlApplicationContext

他是从磁盘路径加载配置文件，配置文件可以放在磁盘的任意位置

1
2
//从指定目录下加载配置文件
FileSystemXmlApplicationContext context = new FileSystemXmlApplicationContext("D:\\code\\day15-1\\s\\src\\main\\resources\\applicationContext.xml");

AnnotationConfigApplicationContext

当使用注解方式配置容器对象时，需要使用此类创建Spring容器。它用来读取注解(后面介绍)

1
ApplicationContext applicationContext = new AnnotationConfigApplicationContext(SpringConfiguration.class);

getBean()方法的使用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
package cn.itcast.dao.impl;

import cn.itcast.dao.UserDao;
import org.junit.Test;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import static org.junit.Assert.*;

public class UserDaoImplTest {

    @Test
    public void save() {
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        //方式1：通过beanid查找对应的bean对象
        UserDao userDao1 = (UserDao)context.getBean("userDao");
        System.out.println(userDao1);
        //方式2：通过bean的类型查找相应的bean对象,此种方式的缺陷：UserDao接口的实现类只能有一个，如果有多个则不知道获取哪个，程序会报错
        UserDao userDao2 = context.getBean(UserDao.class);
        System.out.println(userDao2);
    }
}

Spring整合mybatis

点击查看

面试题总结

什么是IOC

IOC是控制反转，就是将对象的创建交由框架管理

什么是DI

DI是依赖注入，就是通过框架给成员变量赋值,框架中称为注入值。注入方式有两种SET注入和构造器注入，开发中一般使用SET注入。

Spring的生命周期

1.实例化(比如Person p = new Person())

2.设置对象属性(比如p.setName(“jack”))

3.初始化 (执行bean标签中init-method属性指定的方法)

4.销毁(执行bean标签中destroy-method属性指定的方法)

作业

  1. 新建user表，字段有 id，username，password ，register_time，sex，age
  2. 使用Junit单元测试完成user表的新增，删除，更新，查询操作
  3. 使用spring+mybatis的技术实现
文章作者: 微信：hao_yongliang
文章链接: https://haoyongliang.gitee.io/2020/01/14/spring/Spring01%E5%85%A5%E9%97%A8%E5%92%8C%E9%85%8D%E7%BD%AE%E4%BF%A1%E6%81%AF/
版权声明: 本博客所有文章除特别声明外，均采用 CC BY-NC-SA 4.0 许可协议。转载请注明来自 郝永亮的主页！
spring
打赏
  • 微信
    微信
  • 支付寶
    支付寶
相关推荐
2020-01-16
Spring02连接池&注解开发&集成Junit
2020-06-10
Spring整合Mybatis
2020-01-18
Spring04 事物
2020-01-17
Spring03 AOP
评论