[Spring]Spring学习笔记（一）

Spring 概念

spring是开源轻量级框架
- AOP：面向切面编程，扩展功能不是修改源代码实现
- IOC ：控制反转，有一个类，在类里面有方法（不是静态方法）把对象的创建通过spring配置创建类对象
一站式框架三层：
- web层 springMVC
- Service层 ioc
- Dao层 jdbcTemplate
spring版本当前最新版本：https://projects.spring.io/spring-framework/#quick-start 官网建议用Maven/Gradle安装

Spring的ioc操作

把对象的创建交给spring进行管理
ioc操作两部分：
- Ioc的配置文件方式
- Ioc的注解方式

IOC底层原理

ioc底层原理使用技术
1. xml配置文件
2. Dom4j解决xml
3. 工厂设计模式
4. 反射

IOC使用方法（简单样例）：

导入jar包（用Maven/Gradle直接导入）
编写要操作的类（简单的User类）

创建Spring配置文件，通过配置创建类：

在src下创建xml文件，官方建议为applicationContext.xml
引入schema约束，来源：https://docs.spring.io/spring/docs/4.2.x/spring-framework-reference/html/xsd-configuration.html 要加入的代码

配置对象创建

<bean id="对象名" class="类的路径（org.springframework.abcdef）"></bean>

编写测试代码

    import org.junit.Test;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;

    public class testIOC {
        @Test
        public void testMain() {
            ApplicationContext context = new ClassPathXmlApplicationContext("a.xml");
            Main m = (Main) context.getBean("m");
            System.out.println(m);
            m.add();
        }
    }

注：Maven自带的Junit版本为3.8.2，无法使用注解方式，故应手动修改为4.0以上版本才可使用注解。测试结果如上图

在spring里面通过配置文件创建对象

Beans 实例化有三种方式：

第一种使用类的无参数构造创建（重点）类里面没有无参数的构造，会出现异常
第二种使用静态工厂创建创建静态方法返回类对象
根据类调用静态方法 <bean id=”bean2” class=”****” factory-method=”getBean2”>
第三种使用实例工厂创建创建不是静态的方法，返回类对象先创建工厂对象 <bean id=”bean3factory” class=”bean3类”> 再创建目标类，通过工厂对象里的方法构造 <bean id=”bean3” factory-bean=”bean3factory” factory-method-”getBean3”>

Bean标签常用属性

id属性起名称，任意命名 Id属性值不能包含特殊符号，根据id值得到配置对象
class属性：创建对象所在类的全路径
name属性：与id本身功能一样，但name可以加特殊符号（遗留问题）
scope属性： singleton 单例默认值只有一个对象 Prototype 多例多实例对象不常用： Request 创建对象并把对象放到request域内 Session创建对象并把对象放到session域内 Globalsession 创建对象并把对象放到globalsession域内

属性注入

创建对象的时候，向类里面的属性设置值

属性注入的三种方式：

有参构造：（constructor-arg，构造函数为User(string username) ）

<bean id="demo1" class="类"> 
    <constructor-arg name="username" value="值"></constructor-arg> 
</bean>

Set方法构造：（property，构造函数没有参数，但类中有set方法）

<bean id="demo2" class="类"> 
    <property name="bookname" value="值"></property> 
</bean>

注入对象类型属性（属性可能是自定义对象）

创建service类和dao类，同时在service得到dao对象

具体实现过程

在service里面把dao作为类型属性
生成dao类型属性的set方法
配置文件中设置注入关系

<bean id=”userDao” class=”dao”></bean> 
<bean id=”userService” class=”service”> 
    <!-- 不写value 写ref属性 对应ID --> 
    <property name=”userDao” ref=”userDao”></property> 
</bean>

P名称空间注入：

注入复杂类型属性

数组
list集合
map集合
properties类型

数组与list集合

<bean id=”person” class=”类”> 
    <!-- 数组 list--> 
    <property name=”arrs”> 
        <list> 
            <value>aaa</value> 
            <value>ada</value> 
            <value>aba</value> 
        </list> 
    </property> 
    <!-- map --> 
    <property name=”map”> 
        <map> 
            <entry key=”aa” value=”lucy”></entry> 
            <entry key=”bb” value=”ldcy”></entry> 
            <entry key=”cc” value=”luacy”></entry> 
        </map> 
    </property> 
    <property name=”properties”> 
        <props> 
            <prop key=”driverclass”>com.mysql.jdbc.Driver</prop> 
            <prop key=”username”>user</prop> 
            …… 
        </props> 
    </property> 
</bean>

IOC和DI区别

IOC：控制反转，把对象创建交给spring进行配置
DI：依赖注入，向类里面的属性中设置值
关系：依赖注入不能单独存在，需要在ioc基础之上完成操作

Spring整合Web项目原理

加载spring核心配置文件通过new来创建对象，虽然功能可以实现，但是效率很低
实现思想：把加载配置文件和创建对象过程，在服务器启动时候完成。
实现原理：
1. servletContext对象
2. 监听器
3. 具体使用（原理、已封装）在服务器启动时，为每个项目创建ServletContext对象在servletContext对象创建手，使用监听器可以具体到ServletContext对象在什么时候创建使用监听器监听到ServletContext对象创建时候，加载spring配置文件，把配置文件配置对象创建把创建出来的对象放到SERVLETcONTEXT域对象里面（setAttribute方法）获取对象时候，到ServletContext域得到（getAttribute方法）

[Spring]Spring学习笔记（二）

Spring的bean管理（注解）

注解介绍

代码里面特殊标记，使用注解可以完成功能
注解写法 @注解名称(属性名称=属性值)
注解使用在类上面，方法上面和属性上面

Spring注解开发准备工作

导入jar包
1. 导入基本的jar包
2. 导入aop的jar包
创建类，创建方法
创建Spring配置文件，引入约束
1. ioc基本功能，引入约束
2. 做Spring的ioc注解开发，引入新的约束

注解创建对象

配置文件中，开启注解扫描

到包里面扫描类、方法、属性上面是否有注解

<context:component-scan base-package=”包名”></context:component-scan>

只扫描属性上面的注解

context:annotation-config

注解注入属性

在创建对象的类上面使用注解实现

@Component(value=”user”) //<bean id=”user” class=”” />
Public class User{
……

创建对象有4个注解注：功能一样

@Component
@Controller
@Service
@Repository

创建对象是单实例还是多实例 @Scope(value=”prototype/singleton”)

注解注入属性

创建service类，创建dao类

@Service(value=”userService”)
Public class UserService{
    //得到dao对象
    //定义dao类型属性
    //在dao属性上面使用注解 完成对象注入
    @Autowired
    Private UserDao userDao;
    //使用注解方式的时候不需要使用set方法
    Public void add(){
   ……
    userDao.add();
}
}

通过类名寻找对应的对象进来，自动注入/装配。注入属性的两个对象

@Autowired 自动装配

@Resource(name) 注入指定对象，name为对象名

配置文件和注解混合使用

创建对象操作使用配置文件方式实现，然后注入属性的操作使用注解方式实现。

AOP概念

AOP百度百科

AOP：面向切面（方向）编程，扩展功能不修改源代码实现
AOP采取横向抽取机制，取代了传统纵向集成体系重复性代码（性能监视、事务管理、安全检查、缓存）

AOP原理：

原理图横向机制：无接口情况：使用动态代理实现。

AOP术语

Joinpoint(连接点):所谓连接点是指那些被拦截到的点。在spring中,这些点指的是方法,因为spring只支持方法类型的连接点. 类里面哪些方法可以被增强，这些方法被称为连接点。
Pointcut(切入点):所谓切入点是指我们要对哪些Joinpoint进行拦截的定义. 在类里面可以有很多的方法被增强，比如实际操作中，只是增强了类里面add方法和update方法，实际增强的方法被称为切入点
Advice(通知/增强):所谓通知是指拦截到Joinpoint之后所要做的事情就是通知.通知分为前置通知,后置通知,异常通知,最终通知,环绕通知(切面要完成的功能) 增强的逻辑，称为增强，比如扩展日志功能，这个日志功能称为增强前置通知：在方法之前执行后置通知：在方法之后执行异常通知：方法出现异常最终通知：在后置之后执行环绕通知：在方法之前和之后执行
Introduction(引介):引介是一种特殊的通知在不修改类代码的前提下, Introduction可以在运行期为类动态地添加一些方法或Field.（一般不用）用动态的方式向类中加属性/方法
Target(目标对象):代理的目标对象（要增强的类）
Weaving(织入):是指把增强应用到目标对象来创建新的代理对象的过程.spring采用动态代理织入，而AspectJ采用编译期织入和类装在期织入。是把advice应用到target的过程
Proxy（代理）:一个类被AOP织入增强后，就产生一个结果代理类
Aspect(切面): 是切入点和通知（引介）的结合把增强应用到具体方法上面，把增强用到切入点的过程。

Spring的aop操作

在Spring里面进aop操作，使用aspectJ实现
1. aspectj不是spring的一部分，和spring一起使用进行aop操作
2. Spring2.0以后增加了对aspectj的支持
使用aspectj实现aop有两种方式
1. 基于aspectj的xml配置
2. 基于aspectj的注解方式

AOP操作准备

除了导入基本的jar包外，还需要导入aop相关的jar包。
创建spring核心配置文件，导入aop的约束

来源：https://docs.spring.io/spring/docs/4.2.x/spring-framework-reference/html/xsd-configuration.html

使用表达式配置切入点

切入点，实际增强的方法
常用的表达式规则：execution(<访问修饰符>?<返回类型><方法名>(<参数>)<异常>)
1. execution(* cn.itcast.aop.Book.add(..)) 某个方法
2. execution(* cn.itcast.aop.Book.*(..)) 某个类中的所有方法
3. execution(* .(..)) //所有类中的所有方法
4. 匹配所有save开头的方法execution(* save*(..))

Aspectj的aop操作

<!--配置对象-->
<bean id=”book”&nbsp;class=”类”></bean>
<bean id=”myBook”&nbsp;class=”类”></bean>
<!--配置aop操作-->
<aop:config>
<!--配置切入点-->
<aop:pointcut expression=”execution(* cn.itcast.aop.Book.*(..))”&nbsp;id=”pointcut1”&nbsp;/>
<!--配置切面-->
<aop:aspect ref=”myBook”>
<!--配置增强类型 method，增强类里面使用哪个方法作为前置-->
<!--前置-->
<aop:before method=”before1”&nbsp;pointcut-ref=”pointcut1”/>
<!--后置-->
<aop:after-returning method=”after1”&nbsp;pointcut-ref=”pointcut1”&nbsp;/>
<!--环绕-->
<aop:around method=”around1”&nbsp;pointcut-ref=”pointcut1”&nbsp;/>
</aop:aspect>
</aop:config>

环绕：

//MyBook类
Public void around1(ProceedingJoinPoint proceedingJoinPoint){
    //方法之前
    System.out.println(“方法之前”);
    //执行被增强的方法
    proceedingJoinPoint.proceed();
    //方法之后
    System.out.println(“方法之后”);
}

Log4j介绍

通过log4j可以看到程序运行过程中更详细的信息
1. 经常使用log4j查看日志
使用
1. 导入log4j的jar包
2. 赋值log4j的配置文件，复制到src下面Log4j.properties
设置日志级别
1. info看到基本信息
2. debug 看到详细信息

Spring整合web项目演示

演示问题每次访问action时，都会加载spring配置文件 action调用service，service调用dao
解决方案
1. 在服务器启动的时候，创建对象加载配置文件。
2. 底层使用监听器，servletcontext对象
在spring里面不需要我们自己写代码实现，帮忙封装
1. 封装了一个监听器，只需要配置监听器就可以了
2. 需先导入整合web项目的jar包，spring-web
```

<listener>
<listener-class>
    Org.springframework.web.context.ContextLoaderListener
</listener-class>
</listenner>
```
1. 指定加载spring配置文件位置

[Spring]Spring学习笔记（一）#

Spring 概念#

Spring的ioc操作#

IOC底层原理#

IOC使用方法（简单样例）：#

在spring里面通过配置文件创建对象#

Bean标签常用属性#

属性注入#

注入复杂类型属性#

IOC和DI区别#

Spring整合Web项目原理#

[Spring]Spring学习笔记（二）#

Spring的bean管理（注解）#

注解介绍#

Spring注解开发准备工作#

注解创建对象#

注解注入属性#

注解注入属性#

AOP概念#

AOP原理：#

AOP术语#

Spring的aop操作#

AOP操作准备#

使用表达式配置切入点#

Aspectj的aop操作#

Log4j介绍#

Spring整合web项目演示#

[Spring]Spring学习笔记（一）

Spring 概念

Spring的ioc操作

IOC底层原理

IOC使用方法（简单样例）：

在spring里面通过配置文件创建对象

Bean标签常用属性

属性注入

注入复杂类型属性

IOC和DI区别

Spring整合Web项目原理

[Spring]Spring学习笔记（二）

Spring的bean管理（注解）

注解介绍

Spring注解开发准备工作

注解创建对象

注解注入属性

注解注入属性

AOP概念

AOP原理：

AOP术语

Spring的aop操作

AOP操作准备

使用表达式配置切入点

Aspectj的aop操作

Log4j介绍

Spring整合web项目演示