投稿
  1. 首页
  2. java

Spring快速入门

code • 2022-5-5 • java • 阅读 51

Spring快速入门,第1张

1 Spring 1.1 简介

  • Spring 春天–>给软件行业带来了春天

  • 2002 首次推出了spring框架的雏形，interface21框架

  • spring框架即以interface21框架为基础，经过重新设计 ，并不断丰富其内涵，与2004年3月24日，发布了11.0正式版

  • Rod Johnson 该框架的创始人，著名作者，音乐学的博士，悉尼大学

  • spring理念，使现有的技术更加容易使用，本身是一个大杂烩

  • SSH：Struct2+Spring+Hibernate

  • SSM：SpringMvc+Spring+Mybatis



    org.springframework
    spring-webmvc
    5.3.18



    org.springframework
    spring-jdbc
    5.3.18
1.2 优点
  • spring是一个开源免费的框架（容器）
  • Spring 是一个轻量级的、非入侵的框架（不会对源码产生任何影响，只会简化代码）
  • 控制反转（IOC），面向切面编程（AOP）
  • 支持事务的处理，对框架整合的支持

总结一句话，Spring就是一个轻量级的控制反转IOC和面向切面编程AOP的框架

1.3 组成 1.4扩展

在Spring的官网有这个介绍：现代化的java开发，说白就是基于spring的开发

  • spring boot
    • 一个快速开发的脚手架
    • 基于springboot可以快速的开发单个微服务
    • 约定大于配置！
  • spring cloud
    • springCloud是基于springboot实现的

因为现在大多数公司都在使用springBoot进行快速开发，学习springboot的前提，需要完全掌握spring及springMVC

弊端：发展了太久，违背了原来的理念！配置十分繁琐，人称“配置地狱！”

2.IOC理论推导
  1. UserDao接口
  2. UserDaoImpl实现类
  3. UserService业务接口
  4. UserServiceimpl业务实现类

在我们之前的业务中，用户的需求可能会影响我们原来的代码，我们需要根据用户的需求去修改源代码！如果程序代码量十分大，成本巨大。

我们使用一个set接口实现，已经发生革命性的变化！

private UserDao userDao;
public void setUserDao(UserDao userDao){
    this.userDao=userDao;
}
  • 之前，程序是主动创建对象！控制权在程序猿手上！
  • 使用set注入后，程序不在具有主动性，而是变成被动的接受对象

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

IOC本质

控制反转IoC(Inversion of Control)，是一种设计思想，DI(依赖注入)是实现IoC的一种方法，也有人认为DI只是IoC的另一种说法。没有IoC的程序中 , 我们使用面向对象编程 , 对象的创建与对象间的依赖关系完全硬编码在程序中，对象的创建由程序自己控制，控制反转后将对象的创建转移给第三方，个人认为所谓控制反转就是：获得依赖对象的方式反转了。

采用XML方式配置Bean的时候，Bean的定义信息是和实现分离的，而采用注解的方式可以把两者合为一体，Bean的定义信息直接以注解的形式定义在实现类中，从而达到了零配置的目的。

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

3.HelloSpring


4.IOC创建对象的方式

  1. 使用无参构造创建对象，默认！ 如果User类没有无参构造则报错

    <bean id="user" class="com.kuang.pojo.User">
    <property name="name" value="秦江"/>
bean>

  2. 假设我们要使用有参构造创建对象

    1. 下标赋值

      <bean id="user" class="com.kuang.pojo.User">
    <constructor-arg index="0" value="狂神说java"/>
bean>

    2. 通过类型创建，不建议使用，如果有两个同类型的参数，则会出错

      <bean id="user" class="com.kuang.pojo.User">
    <constructor-arg type="java.lang.String" value="qingjanga"/>
bean>

    3. 通过参数名来设置

      <bean id="user" class="com.kuang.pojo.User">
    <constructor-arg name="name" value="sdfasdfasdf"/>
bean>

总结：在配置文件加载的时候，容器中管理的对象就已经初始化了

5、spring配置 5.1、别名
5.2、bean的配置

id:bean的唯一标识符

class bean对象所对应的全限定名

name：也是别名

<bean id="user" class="com.kuang.pojo.User" name="u1,u2,u3">
    <constructor-arg name="name" value="西部开源"/>
bean>
5.3、import

一般用于团队开发使用，他可以将多个配置文件，导入合并为一个

假设，现在项目中有多个人开发，这三个人复制不同的类开发，不同的类需要注册在不同的bean中，我们可以利用import将所有的beans.xml合并为一个总的

使用总配置即可

6、依赖注入 6.1构造器注入

前面已讲

6.2set方式注入 重点*
  • 依赖注入：set注入
    • 依赖：bean对象的创建依赖于容器
    • 注入：bean对象中的所有属性，由容器来注入

【环境搭建】

  1. 复杂类型

    public class Address {
    private String address;

    public Address() {
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    public Address(String address) {
        this.address = address;
    }
}

  2. 真实测试环境

    public class Student {
    private String name;
    private Address address;
    private String[] books;
    private List<String> hobbys;
    private Map<String,String> card;
    private Set<String> games;
    private Properties info;
    private String wife;

  3. beans.xml

    
<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">
    <bean id="student" class="com.kuang.pojo.Student">
        
        <property name="name" value="zzy"/>
    bean>

beans>

  4. 测试类

    public class MyTest {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        Student student = (Student)context.getBean("student");
        System.out.println(student);

完善注入信息


<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">
    <bean id="student" class="com.kuang.pojo.Student">
        
        <property name="name" value="zzy"/>
        
        <property name="address" ref="address"/>
        
        <property name="books">
            <array>
                <value>红楼梦value>
                <value>西游记value>
                <value>水浒传value>
                <value>三国演义value>
            array>
        property>
        <property name="hobbys">
            <list>
                <value>听歌value>
                <value>敲代码value>
                <value>看电影value>
            list>
        property>
        
        <property name="card">
            <map>
                <entry key="身份z" value="132115313212351513"/>
                <entry key="yhk" value="251616511515151"/>
            map>
        property>
        <property name="games">
            <set>
                <value>LOLvalue>
                <value>王者荣耀value>
                <value>反恐精英value>
                <value>炉石传说value>

            set>
        property>
        
        <property name="wife">
            <null/>
        property>
        
        <property name="info">
            <props>
                <prop key="学号">2015014285prop>
                <prop key="姓名">小明prop>
                <prop key="性别">男prop>


            props>
        property>
    bean>

    <bean id="address" class="com.kuang.pojo.Address">
        <property name="address" value="浙江万里"/>
    bean>
beans>

常用

6.3扩展方式注入

我们可以使用p命名空间和c命名空间进行注入

官方解释：（主要是带p和c那两行）


<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:p="http://www.springframework.org/schema/p"
       xmlns:c="http://www.springframework.org/schema/c"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd">

使用！


<bean id="user" class="com.kuang.pojo.User" p:name="zzy" p:age="180"/>

<bean id="user2" class="com.kuang.pojo.User" c:age="18" c:name="zzy"/>

测试：

    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        Student student = (Student)context.getBean("student");
        System.out.println(student);
/* com.kuang.pojo.Student{
name='zzy',
address=Address{address='浙江万里'},
books=[红楼梦, 西游记, 水浒传, 三国演义],
hobbys=[听歌, 敲代码, 看电影],
card={身份z=132115313212351513, yhk=251616511515151},
games=[LOL, 王者荣耀, 反恐精英, 炉石传说],
info={姓名=小明, 学号=2015014285, 性别=男},
wife='null'}
    */
    }
    @Test
    public void Test1(){
        ApplicationContext context = new ClassPathXmlApplicationContext("userbeans.xml");
        User user = (User)context.getBean("user2");
        System.out.println(user);
    }

注意点：p命名空间和c命名空间不能直接使用，需要导入xml约束

   xmlns:p="http://www.springframework.org/schema/p"
   xmlns:c="http://www.springframework.org/schema/c"
6.4bean的作用域

  1. 代理模式（Spring默认机制）、


<bean id="user2" class="com.kuang.pojo.User" c:age="18" c:name="zzy" scope="singleton"/>

  1. 原型模式 ：每次从容器中get的时候，都会产生一个新对象！

    
<bean id="user2" class="com.kuang.pojo.User" c:age="18" c:name="zzy" scope="prototype"/>

  2. 其余的request、session、application这些只能在web开发中使用到

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

在spring中有三种装配的方式

  1. 在xml中显示的配置
  2. 在java中显示配置
  3. 隐式的自动装配bean 【重要】
7.1 测试

环境搭建，一个人有两个宠物

<bean id="cat" class="com.kuang.pojo.Cat"/>
<bean id="dog" class="com.kuang.pojo.Dog"/>
<bean id="people" class="com.kuang.pojo.People">
    <property name="name" value="常雾岩"/>
    <property name="dog" ref="dog"/>
    <property name="cat" ref="cat"/>
bean>
7.2、ByName自动装配

byname会自动在容器上下文中查找，和自己对象set方法后面的值对应的beanid！

<bean id="cat" class="com.kuang.pojo.Cat"/>
<bean id="dog" class="com.kuang.pojo.Dog"/>
<bean id="people" class="com.kuang.pojo.People" autowire="byName">
    <property name="name" value="常雾岩"/>
bean>
7.3 ByType自动装配

类型必须全局唯一

<bean id="cat11" class="com.kuang.pojo.Cat"/>
<bean id="dog22" class="com.kuang.pojo.Dog"/>
<bean id="people" class="com.kuang.pojo.People" autowire="byType">
    <property name="name" value="常雾岩"/>
bean>

小结：

  1. byname的时候，需要保证所有bean的id唯一，并且这个bean需要和自动注入的属性的set方法的值一致
  2. bytype的时候，需要保证所有bean的class唯一，并且这个bean需要和自动注入的属性类型一致
7.4、使用注解实现自动装配

jdk1.5支持的注解，spring2.5就支持注解了

需使用注解须知：

  1. 导入约束:context约束
  2. 配置注解的支持：context:annotation-config/
`
<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>

@Autowired

直接在属性上使用即可！也可以在set方式上使用！

使用autowired我们可以不用编写set方法了，前提是你这个自动装配的属性在IOC（spring）容器中存在，且符合名字byname！

科普：

@Nullable 字段标记了这个注解，说明这个字段可以为null；

public @interface Autowired {
    boolean required() default true;
}
@Autowired(required=false)

如果显示定义了Autowired的required属性为false，说明这个对象可以为null，否则不允许为空

如果@Autowired自动装配的环境比较复杂，自动装配无法通过一个注解@Autowired完成的时候，我们可以使用@Qualifier(value=“xxx”)去配置@Autowired使用（这里的xxx是bean里面的id），指定一个唯一的bean对象注入

public class People {
    @Autowired
    @Qualifier(value = "cat333")
    private Cat cat;
    @Autowired
    @Qualifier(value = "dog222")
    private Dog dog;
    private String name;

还有@Resource注解，也可以完成上述的@Autowired，最常用的是@Autowired

@Resource注解

public class People{
    @Resource(name="cat2")
    private Cat cat;
    @Resource
    private Dog dog;
}

小结

@Resource和@Autowired的区别：

  • 都是用来自动装配的，都可以放在属性字段上
  • @Autowired通过byname的方式实现，而且必须要求这个对象存在
  • @Resource默认通过byname方式实现，如果找不到名字，则通过bytype实现，如果两个都找不到的情况下，就报错
  • 执行顺序不同:@Autowired 通过byType的方式实现
8、使用注解开发

在spring4之后，要使用注解开发，必须导入aop包

使用注解需要入context约束，增加注解的支持！

  1. bean

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

beans>

  2. 属性如何注入

  1. 衍生的注解

    ​ @Component有几个衍生注解，我们在web开发中，会按照mvc三层架构分层

    • dao 【@Repository】

    • service 【@Service】

    • controller 【@Controller】

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

  2. 自动装配

  1. 作用域

  2. 小结

    xml与注解：

    • xml更加万能，适用于任何场合！维护简单方便
    • 注解不是自己类使用不了，维护相对复杂！

    xml与注解最佳实践

    • xml用来管理bean
    • 注解只负责完成属性的注入
    • 我们在使用的过程中，只需要注意一个问题：必须让注解生效，就需要开启注解的支持

<context:annotation-config/>

<context:component-scan base-package="com.kuang"/>

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

@Value：放在变量上，给变量赋值。当属性较少并且复杂度低时使用，属性很复杂建议直接使用配置文件

9.使用java的方式配置spring

我们现在要完全不适用spring的xml配置了，全权交给java来做！

javaConfig是spring的一个子项目

实体类

package com.kuang.pojo;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
//这里的注解意思是：这个类被spring接管了，注册到了容器中
@Component
public class User {
    @Value("楚云升")
    private String name;

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                '}';
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

配置文件

package com.kuang.config;

import com.kuang.pojo.User;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;
//这个也会被spring容器托管，注册到容器中，因为它本来就是一个@Component  @Configuration代表这是一个配置类
//就和我们之前看的beans.xml

@Configuration
@ComponentScan("com.kuang.pojo")
@Import(KuangConfig2.class)
public class KuangConfig {
    //注册一个bean，就相当于我们之前写的一个bean标签
    //这个方法的名字，就相当于bean标签中的id属性
    //这个方法的返回值，就相当于bean标签中的class属性
    @Bean
    public User getUser(){
        return new User();
    }
}

测试类！

public class MyTest {
    public static void main(String[] args) {
        //如果完全使用了配置类的方式去做，我们就只能通过AnnotationConfig上下文来获取容器，通过配置类的class对象加载
        ApplicationContext context = new AnnotationConfigApplicationContext(KuangConfig.class);
        User user = (User)context.getBean("getUser");
        System.out.println(user);
    }
}

这种纯java的配置文件，在springboot中随处可见！

以上的纯java配置文件，可以与xml配置文件相对于的看，相对于两种方法

10、代理模式

为什么要学习代理模式？因为这就是springAOP的底层！！！ 【SpringAOP和SpringMVC，面试必问】

代理模式的分类

  • 静态代理
  • 动态代理

10.1 静态代理

角色分析：

  • 抽象角色：一般会使用接口或抽象类来解决
  • 真实角色：被代理的角色
  • 代理角色：代理真实角色，代理真实角色后，我们一般会做些附属 *** 作
  • 客户：访问代理对象的人

代码步骤：

  1. 接口

    //租房
public interface Rent {
    public void rent();
}

  2. 真实角色

    public class Host implements Rent{

    public void rent() {
        System.out.println("房东要出租房子！");
    }
}

  3. 代理角色

    package com.kuang.demo01;

public class Proxy implements Rent{
    private Host host;

    public Proxy(Host host) {
        this.host = host;
    }

    public Proxy() {
    }

    public void rent() {
        host.rent();
        seeHouse();
        heTong();
        fare();

    }
    //看房
    public void seeHouse(){
        System.out.println("中介带你看房！");
    }
    //收中介费
    public void fare(){
        System.out.println("收取中介费！！");
    }
    //看房
    public void heTong(){
        System.out.println("签租赁合同！ ");
    }
}

  4. 客户端访问代理角色

    public class Client {
    public static void main(String[] args) {
        Host host = new Host();
        Proxy proxy = new Proxy(host);
        proxy.rent();
    }
}

代理模式的好处！

  • 可以使真实角色的 *** 作更加纯粹！不用去关注一些公共的业务
  • 公共也就交给代理角色，实现了业务的分工
  • 公共业务发生扩展的时候，方便集中管理！

缺点：

  • 一个真实角色就会产生一个代理角色：代码量会翻倍开发效率会变低
10.2 加深理解

代理，减少对原代码的修改，通过代理的方式，给原程序增加功能，并不做修改

AOP聊聊

代码：对应08-demo02

10.3 动态代理
  • 动态代理和静态代理角色一样
  • 动态代理的代理类是动态生成的，不是我们直接写好的
  • 动态代理分为两大类：基于接口的动态代理，基于类的动态代理
    • 基于接口–JDK动态代理【我们在这里使用】
    • 基于类：cglib
    • java字节码实现：javasist

需要了解两个类：Proxy（代理），InvocationHandler：调用处理程序

动态代理的好处：

  • 可以使真实角色的 *** 作更加纯粹！不用去关注一些公共的业务
  • 公共也就交给代理角色，实现了业务的分工
  • 公共业务发生扩展的时候，方便集中管理！
  • 一个动态代理类代理的是一个接口，一般就是对应的一类业务
  • 一个动态代理类可以可以代理多个类，只要是实现了同一个接口即可
11、AOP 11.1、什么是AOP

11.2 AOP在Spring中的作用

提供声明式事务：允许用户自定义切面

11.3 使用spring实现AOP

使用AOP，需要导入一个依赖包

        <dependency>
            <groupId>org.aspectjgroupId>
            <artifactId>aspectjweaverartifactId>
            <version>1.9.6version>
        dependency>

方式一：使用spring的API接口 【主要springAPI接口实现】

方式二：自定义实现AOP 【主要是切面定义】 建议第二种

方式三：使用注解实现！

12、整合MyBatis

步骤

  1. 导入相关jar包
    • junit
    • mybatis
    • mysql数据库
    • spring相关的
    • aop植入
    • mybatis-spring 【new】
  2. 编写配置文件
  3. 测试
12.1 回忆mybatis

  1. 编写实体类

  2. 编写核心配置文件

  3. 编写接口

  4. 编写数据源配置

  5. SqlSessionFactory

  6. SqlSessionTemplate

  7. 需要给接口加实现类

  8. 将自己写的实现类，注入到spring中

  9. 测试使用即可

13、声明式事务 1、回顾事务
  • 把一组事务当成一个业务来做，要么都成功，要么都失败
  • 事务在项目开发中，十分重要，涉及到数据一致性问题，不能马虎！
  • 确保完整性和一致性

事务的ACID原则:

  • 原子性 atomicity
  • 一致性 consistency
  • 持久性 isolation
    • 事务一旦提交，无论系统发生什么问题，结果都不会再被影响，被持久化写到储存器里
  • 隔离性 durability
    • 多个业务可能 *** 作同一个资源，防止数据破坏
2、spring中的事务管理
  • 声明式事务：AOP （交由容器管理事务）
  • 编程式事务管理：需要再代码中，进行事务的管理

为什么需要事务?

  • 如果不配置事务，可能存在数据提交不一致的情况；
  • 如果我们不做spring中配置声明式事务，我们就需要在代码中手动配置事务
  • 事务在项目的开发中十分重要，设计到数据的一致性和完整性，不容马虎！

欢迎分享，转载请注明来源：内存溢出

原文地址: http://outofmemory.cn/langs/789483.html

赞 (0)
打赏 微信扫一扫 微信扫一扫 支付宝扫一扫 支付宝扫一扫
code code 管理员组
0 0
上一篇 2022-05-05
下一篇 2022-05-05

发表评论

登录后才能评论

评论列表（0条）

保存