Spring 基础入门

yq02

已于 2022-11-15 22:30:20 修改

阅读量9.9k

点赞数 2

文章标签： spring java spring boot

于 2022-09-27 09:33:24 首次发布

本文链接：https://blog.csdn.net/weixin_43978588/article/details/127065357

版权

Spring 控制反转依赖注入

SpringFramework

在这里插入图片描述

IOC(Inversion of Control) 控制反转

将程序对象创建的控制权转移到外部，使用对象时，由主动new对象转换为外部提供对象。
spring提供了一个Ioc容器，负责对象的创建、初始化等一些列工作，被Ioc容器创建和管理的对象统称为Bean.

DI（Dependency Injection) 依赖注入

在Ioc容器中建立bean与bean 之间依赖关系的过程，称为依赖注入（DI）。

目的

解耦，使用对象时不仅可以直接从容器中获取，并且取到的bean已经绑定了所有依赖关系。

Ioc实现

1、配置bean

<?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="com.ck.dao.UserDaoImp" scope="prototype" init-method="init" destroy-method="destory"/>
</beans>

2、创建bean

// 获取Ioc容器
ApplicationContext ctx=new ClassPathXmlApplicationContext("applicationContext.xml");
//获取bean  返回对应对象
UserDao userdao=ctx.getBean("userdao");

DI实现

1、配置bean的属性

<?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="com.ck.dao.UserDaoImp" scope="prototype" init-method="init" destroy-method="destory"/>
 <bean id="userService" class="com.ck.dao.UserServiceImp" scope="prototype" >
//<!--property 标签表示配置当前bean属性-->  //删除new创建对象，通过DI代替new创建实例
<property name="userDao" ref="userDao">
</bean>
</beans>

Spring bean配置

bean标签

id 定义bean的id 唯一容器可通过Id获取bean
class 定义bean的类 bean的全路径类名
name 定义bean别名多个之间使用空格、逗号、分号分割
scope 定义bean作用范围，控制创建出的bean是否为同一对象可选参数：prototype/singleton 默认为singleton(单例)

<bean id="userDao" name="user sss" class="com.upc.dao.impl.userImpl" scope="prototyoe"/>

适合交给容器进行管理的bean

表现层对象
业务层对象
数据层对象
工具对象

不适合交给容器管理的bean

记录成员变量属性的类

bean实例化

1、构造方法（常用）
bean本质是对象，使用构造方法创建.
2、使用静态工厂实例化bean factory-method
静态工厂类 userDaoFactory getUserDao()

<bean id="userDao"  class="com.upc.factory.userDaoFactory" factory-method="getUserDao"/>

3、使用实例工厂实例化bean

<bean id="userFactory"  class="com.upc.factory.userDaoFactory"/>
<bean id="userDao"  factory-bean="userfactory" factory-method="getUserDao"/>

4、factorybean(简化方法 3 重要！！）
UserDaoFactoryBean.java

public class UserDaoFactoryBean implements FactoryBean<UserDao>{
	public UserDao getObject() throws Exception{
	return new UserDaoImpl();
}
	public Class<?> getObjectType(){
	return UserDao.class;
	}
}

配置

<bean id="userDao" class="com.upc.factory.UserDaoFactoryBean"/>

bean生命周期

bean生命周期： bean从创建到销毁的整体过程
1、bean配置 init-method destory-method
2、实现接口 InitializingBean ,DisposableBean apterPropertiesSet()方法和 destory方法

过程

初始化容器
1、创建对象
2、执行构造方法
3、执行属性注入（set操作）
== 执行bean初始化方法 ==
使用bean
执行业务操作
关闭/销毁容器
== 执行bean销毁方法 ==

bookDao.java

package com.upc.dao.impl;

public interface bookDao {
    public  void save();
}

bookService.java

package com.upc.dao.impl;

import java.lang.reflect.Array;
import java.util.*;

public class bookDaoImpl implements bookDao {
    private  int[] array;
    private List<String> list;
    private Set<String> set;
    private Map<String,String> map;
    private Properties properties;

    public Properties getProperties() {
        return properties;
    }

    public void setProperties(Properties properties) {
        this.properties = properties;
    }

    public Map<String, String> getMap() {
        return map;
    }

    public void setMap(Map<String, String> map) {
        this.map = map;
    }

    public Set<String> getSet() {
        return set;
    }

    public void setSet(Set<String> set) {
        this.set = set;
    }

    public int[] getArray() {
        return array;
    }

    public void setArray(int[] array) {
        this.array = array;
    }

    public List<String> getList() {
        return list;
    }

    public void setList(List<String> list) {
        this.list = list;
    }

    public void save() {
    System.out.println("save ...");
    System.out.println("数组"+Arrays.toString(array));
    System.out.println(list);
    System.out.println(set);
    System.out.println(map);
    System.out.println(properties);
    }
}

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

<bean id="bookDao" class="com.upc.dao.impl.bookDaoImpl">
    <property name="array">
        <array>
            <value>100</value>
            <value>200</value>
            <value>300</value>
<!--           引用类型 <ref bean="beanId"/>-->
        </array>
    </property>
    <property name="list">
        <list>
            <value>"111"</value>
            <value>"222"</value>
            <value>"333"</value>
        </list>
    </property>
    <property name="set">
        <set>
            <value>100</value>
            <value>100</value>
            <value>300</value>
        </set></property>
        <property name="map">
            <map>
                <entry key="price" value="200"/>
            </map>
        </property>
    <property name="properties">
        <props>
            <prop key="price">200</prop>
        </props>
    </property>


</bean>
</beans>

main.java


import com.upc.dao.impl.bookDao;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class main {
    public static void main(String[] args) {

        ApplicationContext ctx=new ClassPathXmlApplicationContext("applicationContext.xml");
        bookDao bookdao= (bookDao) ctx.getBean("bookDao");
        bookdao.save();

    }
}

结果

在这里插入图片描述

Spring 注解

1、使用@Component定义bean

@Componment("userDao")
public class UserDaoImpl implements UserDao{
}

2、通过组件扫描加载bean

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

@Component注解的衍生注解

-@Controller:用于表现层bean定义
-@Service：用于业务层bean定义
-@Repository:用于数据层bean定义
功能相同，便于理解

@Repository("userDao")
public class UserDaoImpl implements UserDao{
}
@Service("userService")
public class UserServiceImpl implement UserService{
}

Spring3.0 纯注解开发

使用类代替配置文件
配置类 SpringConfig.java

@Configuration  //设置当前类为配置类
@ComponentScan("com.upc")  //设置扫描路径  
public class SpringConfig{
}

初始化容器

//配置文件加载 
//ApplicationContext ctx=new ClassPathXmlApplicationContext("applicationContext.xml");
//加载配置类初始化容器
ApplicationContext ctx=new AnnotationConfigApplicationContext("SpringConfig.class");

Spring AOP

AOP(Aspect Oriented Programming) 面向切面编程，一种编程范式
在不改变原始设计的基础上为其进行功能增强.

AOP

AOP通过预编译方式和运行期动态代理实现，在不修改源代码的情况下，给程序动态统一添加功能的一种技术，简称AOP。是spring框架的一个重要内容，是OOP（面向对象编程）的衍生模范。

在这里插入图片描述

常见的通知

前置通知方法执行前调用对应注解 @Before
后置通知方法执行后调用对应注解 @After
返回通知方法返回后调用对应注解 @AfterReturning
异常通知方法出现异常调用对应注解 @AfterThrowing
环绕通知动态代理、手动推荐方法运行对应注解 @Around

AOP工作流程

1、Spring容器启动
2、读取所有切面配置中的切入点
3、初始化bean，判定bean对应的类中方法是否匹配到切入点

匹配失败，创建对象
匹配成功，创建原始对象（目标对象）的代理对象。 ----------代理模式（增强）
4、获取bean方法执行
匹配失败，获取bean,调用方法并执行。
匹配成功，运行代理对象做增强# Spring MVC

MVC模式

MVC模式（Model–view–controller）是软件工程中的一种软件架构模式，把软件系统分为三个基本部分：模型（Model）、视图（View）和控制器（Controller）。
模型层（Model）负责访问数据库
视图层（View）负责前端页面
控制器层（controller) 处理动态页面的动态数据，控制动态页面的跳转

SpringMVC

Spring MVC将模型拆分成了数据访问层和表示层，表示层调用控制层，控制层调用业务层，业务层调用数据访问层

Spring MVC与Servlet技术功能等同，均属于web层开发技术。

步骤

1、maven 导入Spring MVC 和 Serclet

 <dependency>
        <groupId>javax.servlet</groupId>
        <artifactId>javax.servlet-api</artifactId>
        <version>3.1.0</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-webmvc</artifactId>
        <version>5.1.3.RELEASE</version>
    </dependency>

2、创建控制器类

@Controller
public class UserController{
	//访问路径
	@RequestMapping("/save")
	//返回类型
	@ResponseBody
	public String save(){
		System.out.println("save ..");
		return "{'info':'springmvc'}";
}
}

3、创建Spring MVC 配置类
SpringMvcConfig.java

@Configuration
@ComponentScan("com.upc.controller")
public class SpringMvcConfig{
}

4、初始化servler容器定义servlet容器启动的配置类，加载spring配置

package com.upc.config;

import org.springframework.web.context.WebApplicationContext;
import org.springframework.web.context.support.AnnotationConfigWebApplicationContext;
import org.springframework.web.servlet.support.AbstractDispatcherServletInitializer;

public class ServletConfig extends AbstractDispatcherServletInitializer {
   //加载spring MVC 容器配置
   @Override
   protected WebApplicationContext createServletApplicationContext() {
       AnnotationConfigWebApplicationContext ctx=new AnnotationConfigWebApplicationContext();
       ctx.register(SpringMvcConfig.class);
       return ctx;
   }
   // 设置由Spring MVC处理的请求
   @Override
   protected String[] getServletMappings() {
       //所有请求
       return new String[]{"/"};
   }
   //加载spring容器配置
   @Override
   protected WebApplicationContext createRootApplicationContext() {
       return null;
   }
}

REST 简介

REST (Representational State Transfer) ,表现形式状态转换

传统风格资源描述形式
- http://localhost/user/getUserById?id=1
- http://localhost/user/saveUser
REST风格资源描述形式
- http://localhost/user/1
- http://localhost/user

优点

- 隐藏资源访问行为，无法通过地址得知对资源进行何种操作。
- 书写减缓

按照REST风格访问资源时使用行为动作区分对资源进行的操作

- http://localhost/users 查询全部用户信息（GET）
- http://localhost/users/1 查询指定用户信息（GET）
- http://localhost/users 添加用户信息（POST）
- http://localhost/users 修改用户信息（PUT）
- http://localhost/users/1 删除指定用户信息（DELETE）

根据REST风格对资源进行访问称为RESTful

Spring MVC RESTful

package com.upc.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.*;

@Controller
public class UserController {
    @RequestMapping(value = "/user/{id}",method = RequestMethod.PUT)
    @ResponseBody
    public String update(@PathVariable Integer id){
        System.out.println("update:"+id);
        return "{'module':'update id'}";
    }
}