Spring

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

2.创建一个实体类(User)

3.编写spring配置文件

<?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="user" class="com.ff.spring.bean.User"> </bean>
</beans>

IOC(控制反转)Inverse of Control

将程序中创建对象的控制权反转给spring框架统一管理

spring如何管理：负责对象的创建(实例化)，初始化，对象之间的依赖，功能的增强，对象销毁，整个生命周期进行管理，与之前自己new的对象有区别。这就是反向使用

spring中的bean的管理

1.xml配置方式

在bean标签中配置需要让spring框架进行管理的类

由spring框架创建管理的对象，一般称为一个bean对象，new的对象称为原生对象。

scope的作用域：

singleton 始终只会创建一个Bean对象，在容器启动时创建。

prototype 原型的(多例的) 每次getBean()时都会创建一个新的Bean对象，在每次获取时创建时。

<bean id="admin" name="admin2" class="com.ffyc.ssm.model.Admin" scope="prototype">
       <!--<property name="id" value="10"></property>
       <property name="account" value="admin"></property>-->
       <constructor-arg name="id" value="100"></constructor-arg>
       <constructor-arg name="account" value="admins"></constructor-arg>
</bean>

2.Xml 配置方式依赖注入

spring为我们创建对象时，需要为对象中的属性进行赋值(依赖注入)

注入方式：

1.属性的set方法

2.构造方法

注解标签

<!--
    使用注解标签时，需要在spring.xml中配置一个包名，spring对该包进行扫描
-->
<context:component-scan base-package="com.ffyc.springpro"></context:component-scan>

@Component
@Component(value = "user")@Scope(value = "prototype")
// 代替：  <bean id=" class="com.ffyc.springpro.model.User"/>
@Service

@Repository

@Transactional

添加在类上。表类中所有方法都会添加事物管理；

也可添加在某一方法上，只对此方法添加事物管理。

@Autowired

可以写在字段和 setter 方法上，可以为属性自动注入值，可以添加在属性上,也可以添加在set方法上。添加到属性上，可以不需要set方法，默认值不能为空;可以通过属性类型去spring容器中查找值也可以通过对象的标识去spring容器中查找值

Spring JDBC

1.导入相关jar

在spring配置文件中配置阿里巴巴的数据库连接池管理对象，及spring封装的JDBCTemplate

<!-- spring-jdbc -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-jdbc</artifactId>
    <version>5.2.2.RELEASE</version>
</dependency>
<!-- 阿里数据源 -->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid</artifactId>
    <version>1.1.10</version>
</dependency>

2.导入属性文件

<context:property-placeholder location="config.properties"/>

3.spring 管理与数据库链接 (数据源)

<bean id="dataSource"class="com.alibaba.druid.pool.DruidDataSource">
    <propertyname="driverClassName" value="${driverClassName}"></property>
    <property name="url" value="${url}"></property>
    <property name="username" value="${uname}"></property>
    <property name="password" value="${pwd}"></property>
    <property name="initialSize" value="10"></property>
    <property name="minIdle" value="5"></property>
    <property name="maxActive" value="20"></property>
</bean>

4.配置文件中注入JDBCTemplate

<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
    <property name="dataSource" ref="dataSource"></property>
</bean>

类中获取 JdbcTemplate 对象

@Autowired
    JdbcTemplate jdbcTemplate;

JdbcTemplate 中常用的方法：

jdbcTemplate.update(" ");

jdbcTemplate.insert(" ");

jdbcTemplate.delete(" ");

AOP

(Aspect Oriented Programming)面向切面编程
将程序中的一些非业务代码进行提取,让代理对象调用公共的方法。在不需要修改原来代码的情况下,为程序添加额外的功能。非业务代码(验证权限,打印日志,提交事务,统一异常处理);

是一种编程技巧,不是代替OOP的, 可以使的业务逻辑和非业务逻辑代码进行隔离、降低各个部分之间的耦合度、提高程序的复用性、提高开发效率;

AOP思想不是spring框架特有的,只是spring框架引入使用了这一思想

基本概念

连接点(Joinpoint)：类中可被增强的方法（修改，新增）。

切入点(pointcut)：实际被增强的方法。

通知(Advice)：方法被增强的功能（日志，事务，权限验证）。通知分为：前置、后置、异常、最终、环绕通知。

切面(Aspect):把通知添加到切入点的整个过程称为切面。

目标(Target)：代理的目标对象(连接点,切入点所在类)，真正做这件事的类。

代理(Proxy)：向目标对象应用通知时创建的代理对象。代理对象（帮我们调用通知的那个对象）。

通知

前置通知，在方法执行之前被调用
<aop:before method="saveLog" pointcut-ref="allmethod"></aop:before>
后置通知，在方法正常的执行完成后被调用
<aop:after-returning method="saveLog" pointcut-ref="allmethod"></aop:after-returning>
最终通知，无论方法是否成功执行完成，都会被调用
<aop:after method="saveLog" pointcut-ref="allmethod"></aop:after>
异常通知：方法中出现异常时，才会调用
<aop:after-throwing method="saveLog" pointcut-ref="allmethod" throwing="t"></aop:after-throwing>
环绕通知，更强大，更灵活
<aop:around method="saveLog" pointcut-ref="allmethod"></aop:around>

SpringAOP具体实现：

导入aspectJ 这个aop框架的依赖

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-aspects</artifactId>
    <version>5.2.2.RELEASE</version>
</dependency>

1.xml 配置方式实现

<bean id="aopdemo" class="com.ff.spring.aop.AopDemo"></bean>
<aop:config>
    <!-- 配置切入点 -->
    <aop:pointcut expression="execution(*
    com.ff.spring.service.UserService.adduser(..))" id="adduser"/>
    <aop:pointcut expression="execution(*
    com.ff.spring.service.UserService.*(..))" id="allmethod"/>
    <!-- 配置通知和切入点 -->
    <aop:aspect ref="aopdemo">
    <aop:before method="savelog" pointcut-ref="adduser"/>
    <aop:after method="savelog" pointcut-ref="adduser"/>
    <aop:around method="aroundAdvice" pointcut-ref="adduser"/>
    <aop:after-throwing method="exceptionAdvice" pointcut-ref="allmethod"
    throwing="e" />
</aop:aspect>
</aop:config>

2.注解方式

@Before("execution(* com.ffyc.springpro.dao.*.*(..))")

@After("execution(* com.ffyc.springpro.dao.*.*(..))")

@AfterReturning("execution(* com.ffyc.springpro.dao.*.*(..))")

@AfterThrowing("execution(* com.ffyc.springpro.dao.*.*(..))")

@Around("execution(* com.ffyc.springpro.dao.*.*(..))")

spring事物管理

事物是数据库自身提供的保障数据一致性的功能。一个事物就是一个执行单元,一个单元中可以包含多条sql；
事物的基本特征是原子性特征（保障一个事物中的多条sql要么都执行,要么都不执行）。

jdbc自动事务提交；

mybatis里面,事务默认不自动提交,需要我们在程序中手动提交 sqlsession.commit()；

spring框架里面提供事务管理功能：spring框架已经把提交事务的功能封装好了。

spring中的事务管理有两种:

1.编程式事务管理：

实际开发中使用少，需注入一个事物管理对象TransactionTemplate，只要在代码中手动提交和回滚即可。

2.声名式事物管理：

只需对在事物管理中运行的方法添加注解标签声名即可

声名式事物管理有两种：

1.使用xml配置

<!-- 配置 spring 事务管理类, 并注入数据源 -->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="dataSource"></property>
</bean>

2.使用注解标签

<!-- 开启注解事务管理 -->
<tx:annotation-driven transaction-manager="transactionManager"/>

@Transactional标签用法

   声明式注解管理事务:
一般将 @Transactional标签添加在service中,
       @Transactional可以添加在service层中类上,类中所有的方法都会添加事务管理功
       @Transactional如果只添加在某个方法上,那么表示此方法在事务管理中进行

声明式事物不生效：

1.@Transactional 用在非 public 修饰的方法上

2.异常被catch捕获了，则失效

3.默认编译期异常失效，可以修改配置：@Transactional(rollbackFor = Exception.class)

4.@Transactional 事务传播行为设置错误

5.数据库引擎不支持事务，数据库中只有Innodb支持

6.在同一类中使用非代理对象(this)调用方法

事物传播行为

是当一个事务方法被另一个事务方法调用时，这个事务方法应如何进行。

spring事物传播行为是spring框架提供的特有的控制机制。

事务传播行为不能是同一个类中的方法相互调用，必须是一个类中的方法,调用另一个类中的方法。

例：A方法调用B方法，B是创建一个新事物,还是加入到A事物中运行取决于B的事物传播行为。

Spring集成Mybatis

1.新建一个(web)项目

2.导入相关依赖

spring

mybatis

mysql

junit


        <!--mybtais-->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.4.2</version>
        </dependency>

        <!--mysql-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.16</version>
        </dependency>

        <!-- 阿里巴巴数据源 -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.10</version>
        </dependency>

        <!--junit-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>provided</scope>
        </dependency>

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

        <!--spring-jdbc-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>5.2.2.RELEASE</version>
        </dependency>

        <!--aspectj-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aspects</artifactId>
            <version>5.2.2.RELEASE</version>
        </dependency>

        <!--spring web-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.2.2.RELEASE</version>
        </dependency>

        <!--spring集成mybatis-->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
            <version>1.3.1</version>
        </dependency>

       <!-- 添加跨域过滤器-->
        <dependency>
            <groupId>com.thetransactioncompany</groupId>
            <artifactId>cors-filter</artifactId>
            <version>2.5</version>
        </dependency>

        <!--jackson-->
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>2.14.2</version>
        </dependency>

3.配置 sqlSessionFactory

<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
    <property name="dataSource" ref="dataSource"></property>
    <property name="configLocation" value="mybatis-config.xml"></property>
    <property name="mapperLocations" value="com/ff/*Mapper.xml">
    </property>
</bean>

4.指定生成接口代理

<bean id="mapperFactory" class="org.mybatis.spring.mapper.MapperScannerConfigurer">
    <property name="basePackage" value="com.ff.ssm.dao"></property>
    <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory">
    </property>
</bean>

5.创建代理接口

在 service 中注入 Dao 代理接口，此接口有 Spring实现。

如：

@Autowired
LoginDao loginDao;

小谭同学ha

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
Spring

轻量级：spring中的jar包都较小(核心包)，运行占用的资源较小一站式框架spring核心是统一管理程序中的对象(IOC)；提供了AOP(面向切面编程),还对数据访问层和web层进行了封装；可以很方便的集成其他框架和组件；因此是一个一站式的框架。
复制链接

扫一扫