Spring基础

2019-09-29 本文已影响0人华盛顿可乐

spring简介

基础技术

java
反射
xml
xml解析
代理
大量设计模式

关键在于在容器中获取对象,spring默认是单例模式

基础环境搭建

数据库的操作
<dependency>
  <groupId>mysql</groupId>
  <artifactId>mysql-connector-java</artifactId>
  <version>8.0.13</version>
</dependency>
<dependency>
          <groupId>org.springframework</groupId>
          <artifactId>spring-tx</artifactId>
          <version>5.0.8.RELEASE</version>
</dependency>
<dependency>
          <groupId>org.springframework</groupId>
          <artifactId>spring-jdbc</artifactId>
          <version>5.0.8.RELEASE</version>
      </dependency>
<!-- https://mvnrepository.com/artifact/com.mchange/c3p0 -->
<dependency>
    <groupId>com.mchange</groupId>
    <artifactId>c3p0</artifactId>
    <version>0.9.5.2</version>
</dependency>

添加spring依赖(有四个context,core,beans,expression,但是context依赖其他的3种,所以只需要导入context即可)

<dependency>
          <groupId>org.springframework</groupId>
          <artifactId>spring-context</artifactId>
          <version>5.0.8.RELEASE</version>
</dependency>

编写一个spring的配置文件(放在resources下)

<?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">
<!--将对象的创建交给spring容器,在这个配置文件中声明我要什么对象
    bean标签的class: 写java类的全限定类名,它是通过全类名然后使用反射技术进行创建的
    bean标签的id:标识符,获取对象的时候使用-->
    <bean class="com.sz.pojo.Girl" id="girl">
        <property name="age" value="10"></property>
        <property name="name" value="顶顶顶顶"></property>
    </bean>
</beans>

通过spring的应用程序上下文对象获取对象

@Test
public void m1(){
        //获取上下文对象,spring里面声明对象都需要通过上下文对象获取
        ApplicationContext ctx=new ClassPathXmlApplicationContext("applicationContext.xml");
        Girl girl1 = ctx.getBean("girl", Girl.class);
        System.out.println(girl);
    }

ClassPathXmlApplicationContext()函数里面可以传入String数组,达到读取多个配置文件的目的

核心学习内容

IOC

控制反转(inverse of control)也称依赖注入

控制:创建对象 ,彼此关系的权利

反转:此权利交给了spring容器
spring的配置文件值的注入:

setter注入(最常用):

必须其字段有对应setter方法才可以完成name setName();

通过property子节点完成注入

报错分析:

No default constructor found; nested exception is java.lang.NoSuchMethodException: com.sz.pojo.Girl.<init>()

com.sz.pojo.Girl这个类必须要有无参构造器

构造注入:

<!--前提是Girl有构造方法public Girl(String name, Integer age) constructor-arg里面的name属性与构造器的参数匹配-->
<bean class="com.sz.pojo.Girl" id="girl_demo">
        <constructor-arg name="name" value="wc"></constructor-arg>
        <constructor-arg name="age" value="10"></constructor-arg>
</bean>
<!--前提是Girl有构造方法public Girl(String name)-->
<bean class="com.sz.pojo.Girl" id="girl_demo">
        <constructor-arg name="name" value="wc"></constructor-arg>
</bean>

bean分析

属性分析

abstract(true):表示该bean不能被实例化,只能被继承

parent:表示该bean继承于哪个bean,用id做标识符

init-method:初始化时自动调用的方法,适合数据库连接,数据源的注入

destroy-method:销毁时自动调用的方法

lazy-init(true):默认容器ctx被实例化时就会去执行配置文件applicationContext.xml中里面注册了的bean的无参构造方法

但是调用了这个属性的bean,会在调用bean的时候才执行无参构造方法

scope(prototype):调用该bean声明的对象都是不同的,都是新new出来的

scope(singleton):调用该bean声明的对象是相同的,都是同一个,默认是这种

depends-on:依赖的bean,如果某一个bean严重依赖另一个bean

ApplicationContext ctx=new ClassPathXmlApplicationContext("applicationContext.xml");
((ClassPathXmlApplicationContext) ctx).close();
((ClassPathXmlApplicationContext) ctx).refresh();
//这两个方法调用其中之一才会执行destroy-method方法

子标签分析

property标签:

name(javabean的属性),value(字面值可以表示的),ref(字面值无法表示的)

<bean class="com.sz.pojo.Girl" id="girl">
<property name="age" value="10"></property>
        <property name="name" value="你"></property>
        <property name="dog" ref="dog"></property>
    </bean>
   <bean class="com.sz.pojo.Dog" id="dog">
   </bean>

其他类型

<bean class="com.sz.pojo.Girl" id="girl">
        <property name="age" value="10"></property>
        <property name="name" value="你"></property>
        <property name="dog" ref="dog"></property>
    <!--数组-->
        <property name="str">
            <array>
                <value>刘德华</value>
                <value>郭富城</value>
            </array>
        </property>
    <!--集合-->
        <property name="list">
            <list>
                <value>1</value>
                <value>2</value>
            </list>
        </property>
    <!--list集合里面装dog对象-->
        <property name="listDog">
            <list>
                <!--内部bean无法被外部引用-->
                <bean class="com.sz.pojo.Dog">
                    <property name="name" value="good boy"></property>
                </bean>
                <bean class="com.sz.pojo.Dog">
                    <property name="name" value="good girl"></property>
                </bean>
            </list>
        </property>
    <!--map集合里面装dog对象-->
    <property name="mapDog">
        <map>
        <entry key="dog1">
            <bean class="com.sz.pojo.Dog">
                    <property name="name" value="good boy"></property>
            </bean>
        </entry>
        <entry key="dog2">
            <bean class="com.sz.pojo.Dog">
                    <property name="name" value="good boy"></property>
            </bean>
        </entry>
        </map>
    </property>
    </bean>

自动注入(autowire)

byType:按照类型注入,在上下文搜索对应需要的bean(primary="true"默认也是true)

如果该类型有且只有一个,匹配成功

如果没有该类型则不注入

如果超过一个,则报错

<!--User类里面有类型为Dog的属性-->
<bean class="com.sz.pojo.User" id="user" autowire="byType">
</bean>
    <bean class="com.sz.pojo.Dog">
    <property name="name" value="my Dog"></property>
</bean>

byName:按照javabean对应的pojo里面的属性名来匹配

<!--User类里面有类型为Dog的属性,且属性名为dog-->
<bean class="com.sz.pojo.User" id="user" autowire="byName">
</bean>
    <bean class="com.sz.pojo.Dog" id="dog">
    <property name="name" value="my Dog"></property>
    </bean>

下面的了解即可,用处不大

byConstructor
default
no

引入外部文件

applicationContext.xml中:
<!--通过这种方式引入类路径下的文件-->
<context:property-placeholder location="classpath:jdbc.properties"/>
    <!--这个标签可以将其他的配置文件引入,这样的话,我们将来整体读取这一核心配置文件即可,意思就是要用UserBean.xml里面的bean的话,可以只引入applicationContext.xml-->
 <!--而且classpath:UserBean.xml支持*匹配UserBean-*.xml就会引入所以"UserBean-"开头的xml文件-->
    <import resource="classpath:UserBean.xml"/>
    <bean class="com.sz.dao.ProviderDao">
        <!--${}表达式可以去引用我们引入的这些properties里面的属性的值通过他的键名来得到值-->
        <property name="driver" value="${driver}"/>
        <property name="url" value="${url}"/>
        <property name="user" value="${username}"/>
        <property name="password" value="${password}"/>
    </bean>

常用注解

component

controller(springmvc,强调处理控制层)

service(业务层)

repository(强调数据访问层)

四个注解功能相同

注解里面的userService就是bean的id

package com.sz.service;
@Component("userService")
public class UserService {
    public void eat(){
        System.out.println("吃了");
    }
}

注册com.sz.service下的有@Component注解的bean

application.xml中:
<!--扫描该包以及所有子包-->
<context:component-scan base-package="com.sz.service"/>

AOP(xml版本)

专业术语

target：目标类，需要被代理的类。例如：UserService
Joinpoint(连接点):所谓连接点是指那些可能被拦截到的方法。例如：所有的方法
PointCut 切入点：已经被增强的连接点。例如：addUser()
advice 通知/增强，增强代码。例如：after、before
Weaving(织入):是指把增强advice应用到目标对象target来创建新的代理对象proxy的过程.
proxy 代理类
Aspect(切面): 是切入点pointcut和通知advice的结合

一个线是一个特殊的面。

一个切入点和一个通知，组成成一个特殊的面。

通知

• 前置通知 org.springframework.aop.MethodBeforeAdvice

• 在目标方法执行前实施增强

• 后置通知 org.springframework.aop.MethodAfterAdvice

• 在目标方法执行前实施增强

• 后置返回通知 org.springframework.aop.AfterReturningAdvice

• 在目标方法返回值执行后实施增强

• 环绕通知 org.aopalliance.intercept.MethodInterceptor(功能最强,但是用得少)目标方法的调用由环绕通知决定，即你可以决定是否调用目标方法，而前置和后置通知是不能决定的，他们只是在方法的调用前后执行通知而已，即目标方法肯定是要执行的。

• 在目标方法执行前后实施增强

• 异常抛出通知 org.springframework.aop.ThrowsAdvice

• 在方法抛出异常后实施增强

• 引介通知 org.springframework.aop.IntroductionInterceptor

在目标类中添加一些新的方法和属性

切入点表达式

1.execution() 用于描述方法【掌握】

语法：execution(修饰符返回值包.类.方法名(参数) throws异常)

修饰符，一般省略

public 公共方法

* 任意

返回值，不能省略

void 返回没有值

String 返回值字符串

* 任意

包，[省略]

com.itheima.crm 固定包

com.itheima.crm.*.service com包下面子包任意（例如：com.itheima.crm.staff.service）

com.itheima.crm.. com包下面的所有子包（含自己）

com.itheima.crm.*.service.. com包下面任意子包，固定目录service，service目录任意包

类，[省略]

UserServiceImpl 指定类

*Impl 以Impl结尾

User* 以User开头

* 任意

方法名，不能省略

addUser 固定方法

add* 以add开头

*Do 以Do结尾

* 任意

(参数)

() 无参

(int) 一个整型

(int ,int) 两个

(..) 参数任意

throws ,可省略，一般不写。

步骤

额外补充的依赖

<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>1.9.2</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.aspectj/aspectjrt -->
<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjrt</artifactId>
    <version>1.9.2</version>
</dependency>

配置文件

<?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:aop="http://www.springframework.org/schema/aop"
       xmlns:c="http://www.springframework.org/schema/c"
       xmlns:cache="http://www.springframework.org/schema/cache"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:jee="http://www.springframework.org/schema/jee"
       xmlns:lang="http://www.springframework.org/schema/lang"
       xmlns:p="http://www.springframework.org/schema/p"
       xmlns:task="http://www.springframework.org/schema/task"
       xmlns:util="http://www.springframework.org/schema/util"
       xsi:schemaLocation="http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd
        http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd
        http://www.springframework.org/schema/cache http://www.springframework.org/schema/cache/spring-cache.xsd
        http://www.springframework.org/schema/task http://www.springframework.org/schema/task/spring-task.xsd
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/lang http://www.springframework.org/schema/lang/spring-lang.xsd">
<!--1.aop是基于代理完成的,所以我们要激活我们自动代理-->
    <aop:aspectj-autoproxy/>
    <!--目标类要在spring中注册,没有注册不能作为目标类-->
    <bean class="com.sz.service.ProviderService" id="providerService">
    </bean>
<!--2.注册一个切面要使用的类-->
    <bean class="com.sz.advice.BeforeAdvice" id="beforeAdvice">
    </bean>
<!--3.配置切面的元素-->
<aop:config>
    <aop:aspect  ref="beforeAdvice">
        <!--aop:before表明它确实是前置通知(可以有多个前置通知)
method:指明它使用哪个方法来切beforeAdvice里面的方法名字
pointcut:切入点
你要什么包下面的什么类下面的什么方法
        -->
        <!--execution(* com.sz.service.ProviderService.*())切无参
           execution(* com.sz.service.ProviderService.*(java.lang.Integer))切一个参数是Integer类型的
          execution(* com.sz.service.ProviderService.*(int))切一个参数是int类型的
包装类与基本数据类型有严格的区分
        -->
<aop:before method="methodBefore" pointcut="execution(* com.sz.service.ProviderService.*(..))"></aop:before>
    </aop:aspect>
</aop:config>
</beans>

测试

 ApplicationContext ctx=new ClassPathXmlApplicationContext("application.xml");
 ProviderService demo = ctx.getBean("providerService", ProviderService.class);
 demo.add();

AOP(注解)

@order(数字)注解可以指定before通知的执行顺序,数字小的先执行(类级别的注解)

@order(数字)注解可以指定after通知的执行顺序,数字大的先执行(类级别的注解)

package com.sz.advice;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;
@Order(1)//标记顺序
@Aspect//标记为切面
@Component//相对于在xml中注册bean
public class BeforeAdvice {
    @Before("execution(* com.sz.service.*.*(..))")
    public void before(){
        System.out.println("在一个世纪以前");
    }
}

常见注解总结

Configuration:标明一个类为配置类,然后程序启动的时候只要扫描这个类,就可以清楚所有的配置规则
Component:标明一个类为spring的一个组件,可以被spring容器所管理
Service:同上,语义为服务层
Repository:同上,语义为Dao层
Controller:同上,语义为控制层
ComponentScan:组件扫描,可以绝对去扫描哪些包
Bean:用于在spring容器中注册一个Bean
Autowired:自动注册bean,会按类型装配
@Resource默认按名称装配，如果不到与名称匹配的bean，会按类型装配。

Spring基础

spring简介

基础技术

基础环境搭建

核心学习内容

IOC

bean分析

自动注入(autowire)

引入外部文件

常用注解

component

controller(springmvc,强调处理控制层)

service(业务层)

repository(强调数据访问层)

AOP(xml版本)

专业术语

通知

切入点表达式

步骤

AOP(注解)

常见注解总结

猜你喜欢

热点阅读