spring初级

IOC控制反转（单例模式）

ioc的思想就是创建对象，spring的方式

spring的核心配置 生命周期

初始化：

销毁

scope: 单例设计模式

DI(依赖注入)赋值

usb接口

创建的对象注入给你  就可以使用该对象，持久成的对象给服务层（dao----service）

持久成的对象（spring容器管理）

服务层也可以管理`

di思想就是赋值

=

set方法

构造方法

通过spring整合jdbc

使用阿里云的连接池

开源的连接池DRUID，加入了日志监控（相比这两个c3p0 dbcp）

对sql监控

spring 包 日志包 （2） 连接池和mysql

整合步骤

创建web项目导入依赖

开发表对应的实体类（User）

开发Dao接口和实现类(spring 整合jdbc)

整合jdbc的话要继承一个spring的 JdbcDaoSupport（如下图）

在dao层，实现接口 在接口中药继承实现类JdbcDdaoSupport

继承这个类就可以提供这个对象 来操作sql

​

​

增加 删除  更新

比较简单

查询就比较麻烦一点

public void findById(int id) {

        String sql = "select from s_user where id=?";

       //使用queryForObject(sql,)  返回的是一个泛型query 用list

       getJdbcTemplate().queryForObject(sql, new RowMapper<User>() {

           @Override

           public User mapRow(ResultSet resultSet, int i) throws SQLException {

​                return null;

           }

       }，id);//这个是最后注意的一点   传递一个参数  id

​

其中用的是ResultSet

import java.sql.ResultSet;//这个

其中查询是将rs.getInt("id")这个值  封装到pojo  然后最后返回这个poji

Spring的事物（配置事物）

1、Spring 的 TransactionManager 接口：

在不同平台，操作事务的代码各不相同，因此spring提供了一个 TransactionManager 接口：

DateSourceTransactionManager 用于 JDBC 的事务管理

HibernateTransactionManager 用于 Hibernate 的事务管理

JpaTransactionManager 用于 Jpa 的事务管理

1、添加事务的名称空间

<?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:context="http://www.springframework.org/schema/context"

   xmlns:aop="http://www.springframework.org/schema/aop"

   xmlns:tx="http://www.springframework.org/schema/tx"

   xsi:schemaLocation="http://www.springframework.org/schema/beans

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

       http://www.springframework.org/schema/tx/spring-tx.xsd">

​

3、配置事务管理器

<!-- 事务管理器 -->

<bean name="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">

   <!-- 数据源 -->

   <property name="dataSource" ref="dataSource"></property>

</bean>

​

4、配置通知

<!-- 通知 -->

<tx:advice id="txAdvice" transaction-manager="transactionManager">

   <tx:attributes>

       <!-- 传播行为 -->

       <!-- 支持当前事务，如果不存在，就新建一个 -->

       <tx:method name="save*" propagation="REQUIRED"/>

       <tx:method name="add*" propagation="REQUIRED"/>

       <tx:method name="insert*" propagation="REQUIRED"/>

       <tx:method name="create*" propagation="REQUIRED"/>

       <tx:method name="update*" propagation="REQUIRED"/>

       <tx:method name="modify*" propagation="REQUIRED"/>

       <tx:method name="edit*" propagation="REQUIRED"/>

       <tx:method name="delete*" propagation="REQUIRED"/>

       <tx:method name="remove*" propagation="REQUIRED"/>

       <tx:method name="drop*" propagation="REQUIRED"/>

       <tx:method name="select*" propagation="SUPPORTS"/>

       <tx:method name="get*" propagation="SUPPORTS"/>

       <tx:method name="find*" propagation="SUPPORTS"/>

       <tx:method name="query*" propagation="SUPPORTS"/>

       <tx:method name="search*" propagation="SUPPORTS"/>

   </tx:attributes>

</tx:advice>

​

​

5、配切面

<!-- 切面（将通知织入切入点） -->

<aop:config>

   <!-- 切入点 -->

   <aop:pointcut expression="execution(* com.qfedu.spring.service..*.*(..))" id="txPointcut"/>

   <aop:advisor advice-ref="txAdvice" pointcut-ref="txPointcut"/>

</aop:config>

​

自定义aop和spring事物的执行顺序分析

1、如果先配置spring的事物，后配置自定义的aop，那么事物会在自定义aop通知后提交

2、如果后配置spring的事物，先配置自定义的aop，那么事物会在自定义aop通知前提交

​

​

spring

Spring 是 2003 年兴起的一个轻量级的 Java 开发框架，由 Rod Johnson 创建。它解决了业务逻辑层和其他各层的松耦合问题，并将面向接口的编程思想贯穿整个系统应用。简单来说，Spring 是一个分层的 JavaSE/EEFull-Stack（一站式） 轻量级开源框架。为什么说 spring 是分层、一站式、轻量级的框架呢？

JavaEE 经典的 MVC 三层结构为表现层、业务层、持久层，Web表现层负责页面数据显示、页面跳转调度，例如 JSP/Servlet、SpringMVC；Service业务层负责业务处理、功能逻辑和事务控制，例如 Service、JavaBean、EJB；而持久层Dao则负责数据存取和封装，及与数据库打交道，例如 JDBC、Hibernate、Mybatis。

表现层：Struts1、Struts2、Spring MVC；

业务层：IoC 控制反转、AOP 面向切面编程、事务控制；

持久层：JdbcTemplate、HibernateTemplate、ORM 框架（对象关系映射）的整合。

控制反转即将控制权由原来的程序员自己管理交给 Spring 来管理，依赖注入就是注入对象实例，有四种方式，即接口注入、setter 方法注入、构造器注入和注解注入。

这三大核心分别为 IOC（Inverse of Control 控制反转）、DI（Dependency Injection，依赖注入）和AOP（Aspect Oriented Programming 面向切面编程）。

1.IOC（Inverse of Control 控制反转）

IOC，即将对象创建权利交给Spring工厂进行管理。比如说

Content content = new Content();

现在，可以这样写:

Content content = ContentFactory.getContent();

2.DI（Dependency Injection，依赖注入）

DI 是指在 Spring 框架创建 Bean 对象时，动态地将依赖对象注入到 Bean 组件。简单的说，就是将另外一个 Bean 对象动态地注入到另一个 Bean 中。

DI 的做法是：由 Spring 容器创建 Service、Dao 对象，并且通过注解或配置将 Dao 传入 Servcie，那么 Service 对象就包含了 Dao 对象的引用。比如：

   @Service

   public class UserServiceImpl implements UserService {

   @Autowired //通过注解注入UserMapper对象

   private UserMapper userMapper;

}

3.AOP（Aspect Oriented Programming 面向切面编程）

AOP 采取横向抽取机制，取代了传统纵向继承体系重复性代码的编写方式（例如性能监视、事务管理、安全检查、缓存、日志记录等）。

AOP 基于代理思想，对原来目标对象，创建代理对象，在不修改原对象代码情况下，通过代理对象，调用增强功能的代码，从而对原有业务方法进行增强。例如可以在插入 User 对象之前进行打印日志，请看下面的代码示例。

UserService.java:

publicinterfaceUserService{

voidadd(Useruser);

   }

前置增强类 PrintLogBefore.java：

    //前置增强代码

    public class PrintLogBefore implements MethodBeforeAdvice {

    private static final Logger log = Logger.getLogger(PrintLogBefore.class);

    @Override

    public void before(Method method, Object[] arguments, Object target)

            throws Throwable {

        log.info("在插入User之前执行的方法");

      }

    }

最后配置切入点：

    <bean id="printBefore" class="dreamland.aop.test.PrintLogBefore"></bean>

    <aop:config>

        <aop:pointcut expression="execution(public void save(dreamland.aop.entity.User))" id="pointcut"/>       

        <aop:advisor advice-ref="printBefore" pointcut-ref="pointcut"/>

    </aop:config>

这样在调用 add(User user) 方法之前就会打印如下内容：

"在插入User之前执行的方法"