菜鸟程序猿之Spring学习 - 好文

一、Spring介绍
   Spring是一个开源框架。并且是一个轻量级的框架，能够一站式的分层部署项目。能够整合现在主流框架起到一个粘合剂的作用。

   轻量级
       空间占用角度：
       spring的核心包不到1MB，占用计算机的资源特别小
       对容器的依赖角度：
       对容器依赖性越低越轻量

二、IOC
   1、概念
       IOC就是控制反转将对象创建的权利交给Spring容器来管理。由容器来管理对象的生命周期。

   2、SpringIOC的实现步骤：
       ★导入相关的JAR包
       ★编写实体类
       ★编写配置文件（1.编写配置文件的头    2.编写对象的具体映射关系）
       ★启动spring容器
       ★通过容器获取对象
       ★调用对象的方法完成相应的功能

   3、SpringIOC的原理
       ★控制反转的过程:
           Spring容器在启动的时候，先去读取applicationContext.xml配置文件(读取顺序是按行读取)。
           每当读取到一个bean的时候就会按照bean中的class属性依据反射的方法创建出来对象，把创建
           出来的对象当做value值存储到MAP中，bean的ID当做Map中的key形成键值对的形式，保存到
           Spring容器中，方便以后调用。
       ★对象获取的方法
           a.通过bean中的id能够获取对象
           context.getBean("hello");
           b.通过class属性来获取
           Hello hello = context.getBean(Hello.class);
           注意：
           a.对象获取的时候尽量使用ID,不要用class，可能会由于类型不唯一报错。
           b.如果bean中的ID重复，那么Spring在创建对象时保存到map中的时候就会报错。会报ID已经存在的错误。
           原因：已经存在的bean不能被修改。

三、Spring bean中的属性
   1、别名标签
       <alias name="TareneHello" alias="你好1607"/>

   2、对象的单例和多例
       单例对象：spring容器内部只有一份
       ★Spring容器内部默认维护了一个单例对象。
       ★scope="prototype"
           当scope属性为prototype时根据bean生成的对象就是多例对象。
           ★scope="singleton"
           当scope属性为singleton和默认不写的时候对象创建都是单例的。
       使用场景：
           购物车需要是多例的，否则会造成混论。
       ★懒加载问题
           说明：理想状态下，我们需要什么对象容器帮我们生产什么对象，这是最合理的，这样做既能满足需求又能减少计算机压力

       ★什么是懒加载：
           懒加载就是在容器启动的时候不会创建对象，当通过容器getBean()的时候才会创建对象。这样做能实现最理想的状态。
       ★lazy-init="true" 实现懒加载
           lazy-init="false" 立即加载
           如果默认不写也是立即加载
       ★全局的懒加载配置
           default-lazy-init="true" 就能实现懒加载
           default-lazy-init="false/default" 立即加载

           当bean中的懒加载为default 应该与全局的懒加载配置保持一致。

       ★自定义的初始化和销毁方法
           init-method="init" destroy-method="destroy"
           自定义的初始化和销毁可以手动配置。并且执行。

       ★DI(依赖注入)
           可以通过Spring容器可以动态的注入属性
           1.依赖注入可以为简单类型赋值，也可以为引用类型赋值。
           但是前提条件是属性必须添加setXXX方法。如果没有set方法则不能实现注入。

四、SpringIOC和DI的意义：
   1、如果在架构中web、service、dao 应该尽可能的保持松耦合。如果各层之间紧耦合对于后期代码的维护，相当困难。

   2、Spring可以通过配置文件的形式。动态的实现松耦合。如果将来具体的实现类发生了改变。只需要修改配置文件即可。
   无需手动修改代码。提高了代码的开发效率和维护效率。并且其中所有的注入都是面向接口的，这样做能最大程度保证
   代码的灵活性。

五、自动的装配过程
   如果类中的属性是引用类型，并且配置文件中有相应baen的配置。则能进行自动的装配。（自动的注入）
   1、autowired
       ★spring中可以通过autowire属性实现自动装配。将来不需要手动的在写property能够节省代码。
       ★使用装配过程必须添加set方法。否则装配失败对象属性为null。

   2、装配的原理
       ★autowire="byName"
           使用spring在进行装配的时候会先检查所有的set方法

setStudent====>student======>拿到student以后会根据bean中的ID进行匹配。如果匹配成功则能正确的注入。如果匹配不成功则为null。

       ★autowire="byType"
           使用spring在进行装配的时候会先检查所有的set方法

setStudent====>student===>拿到对应的Class形式====>根据bean中的class类型进行匹配。如果匹配成功则能正确注入。

六、类的注解

   1、开启类扫描
       <context:component-scan base-package="domain"/>
       说明：开启类扫描以后会自动的扫描给定的包及其子包，如果是多个包之间用“,”号隔开

   2、@Component注解使用的原理
       ★首先Spring在进行xml解析时
会解析包扫描的标签。根据标签指定的包进行扫描。然后会到指定的包下查找那些类上有@Component注解，
       找到相应的注解后，会给这个类创建一个对象，创建好对象之后存入MAP中，会根据类的名称生成相应的ID（首字母小写其他不变）。
       当作KEY存入map中。

       ★ID生成的原则
           如果第二个字母是大写的   ABcc ==> 转化以后的ID就是ABcc
           如果第二个字母小写    Abcc====>转化以后ID就是abcc
       ★@Value注解
           @Value注解可以注入字符串和基本类型只需要将注入的值写到
           @Value(value="张三"）即可。就能完成注入。
           如果属性值只有value那么value可以省略不写。

   3、复杂类型的注入
       父类类型的注入需要引入一个util这样的标签
           <util:map id="map">
                <entry key="1" value="一"></entry>
                <entry key="2" value="TOM猫"></entry>
                <entry key="3" value="Jerry老鼠"></entry>
           </util:map>
       要指明map的ID 这个ID就是通过@Value("#{@ID}") ID应该保持一致。
   4、动态数据注入---引入外部配置文件
       <context:property-placeholder location="classpath:/tom.properties"/>
       原理说明：
       spring进行解析的时候会根据指定的路径扫描对应的配置文件，扫描完成以后将配置文件的键值对进行保存。保存到spring容器中。
       需要使用的时候通过@Value("${key}")来获取相应的value值，实现了动态的注入效果。

   5、类扫描的包容性
       在开启类扫描的时候，会默认的开启属性注解。所以属性注解可以省略。

   6、类的注解指明ID
       @Component(value="TomDao")
       说明：使用这个注解的时候默认的条件下会根据类的名称按照首字母小写,自动的生成相应的Bean的ID
       如果有value值那么就会按照value指定的名称当做bean的ID


   7、Spring的分层标识的注解
       @Repository(value="TomDao")    dao层
       @Service("TomService")                 service层
       @Controller                                        控制层
       说明：Spring为了满足分层的需要发明了三个注解分别代码不同的层级

七、SpringAOP
   面向切面编程一种思想
   1、名词解释
       ★切面（Aspect）：一个关注点的模块化，这个关注点可能会横切多个对象。
       一个切面就是在完成目标方法后再执行其操作的程序代码

       ★连接点（Joinpoint）：在程序执行过程中某个特定的点
       就是客户端调用的目标方法。

       ★通知（Advice）：在切面的某个特定的连接点上执行的动作。
       就是切面中的方法。

       ★切入点（Pointcut）：匹配连接点的断言
       切入点就是一个匹配切面的过程

       ★目标对象（Target Object）：被一个或者多个切面所通知的对象。
       就是真正执行目标方法的对象

       ★织入（Weaving）：把切面连接到其它的应用程序类型或者对象上，并创建一个被通知的对象。
       形成切面的过程就是织入

   2、AOP的入门
       步骤：
       ★配置头文件导入约束
       xmlns:aop="http://www.springframework.org/schema/aop"
       ★导入相关的开发jar包
       ★配置自定义的切面
       ★xml配置的顺序
           Content Model : (pointcut*, advisor*, aspect*)
           <aop:config>
                    
                    <aop:pointcut expression="within(service.*)" id="pc"/>
                    <aop:aspect ref="myAspect">
                            
                            <aop:around method="around" pointcut-ref="pc"/>
                    </aop:aspect>

           </aop:config>

   3、AOP的原理
       当创建对象的时候首先spring和和切入点表达式进行匹配。如果匹配成功。则创建代理对象。我们客户端拿到代理对象后看上去和目标对象一模一样。
       调用目标对象执行方法。就会执行切面中的通知（方法）。利用代理对象完成一些额外的操作。最终执行目标方法。

   4、通知的类型
       ★环绕通知（Around Advice）：在目标方法执行之前。执行之后都需要执行额外操作的通知。
       ★前置通知（Before advice）：在目标方法执行之前的操作。
       ★后置通知（After returning advice）：在目标方法执行之后执行的通知
       ★异常通知（After throwing advice）：在执行目标方法时，如果目标方法报错就会被异常通知拦截，这时异常通知才会执行。
       ★最终通知（After (finally) advice）：不管如何都会执行最终通知。

   5、异常的处理
       在Spring中异常的try--catch不能随便加，如果添加了try-catch那么spring容器就捕获不到。不能做出正确的处理。
       如果想写try-catch那么异常捕获时要具体指明某一类的异常不能使用Exception,因为这个异常捕获能力太强。

   6、通知的处理顺序
       当目标方法执行抛出异常时异常通知会被执行，后置通知不会被调用。

   7、通知的使用场景
       ★环绕通知：我是不需要目标方法执行，并且执行前后有必要的操作。
       ★前置通知：日志收集前置通知执行不能影响目标方法是否被执行与它毫无关系。
       ★后置通知：如果需要对目标方法的返回值结果做操作可以使用后置通知。通知通知也不能影响目标方法的执行。
       ★异常通知：可以对异常做收集以后使用异常通知。
       ★最终通知：可以用来关闭一些链接或者释放资源。

   8、通知中的参数
       除了环绕通知之外其他的通知都是JoinPoint。并且所有的参数都必须位于第一位。
       而环绕通知中必须添加ProceedingJoinPoint 因为
只有ProceedingJoinPoint类中有proceed方法。才能让目标方法执行。

   9、关于表达式的写法
       within(service.*)
       它是一个类级别的表达式，可以按照类型来匹配。匹配的规则包名+类名。
       如果想匹配该包下的所有子类用*代替。如果想匹配该包下的所有子孙类用
       ..*表示。

       execution(返回值结果包名.类名.方法名(参数名))
       execution(* service..*(..))
       表达式创建代理对象的原理；
       只有满足表达式要求的才会被创建代理对象，能够精确到方法和参数级别。

八、Spring和JDBC整合
   1、第一步导入jar包

   2、配置数据源
       
       <bean id="dataSource"
class="com.mchange.v2.c3p0.ComboPooledDataSource">
                <property name="driverClass"
value="${c3p0.driver}"></property>
                <property name="jdbcUrl" value="${c3p0.url}"></property>
                <property name="user" value="${c3p0.user}"></property>
                <property name="password" value="${c3p0.password}"></property>
       </bean>

   3、配置JDBCTemplate
       这个是jdbc模板类，可以通过Spring为我们提供的版本进行快速的增删改操作。不需要像原生的jdbc那样复杂的代码。
       <bean id="jdbcTemplate"
class="org.springframework.jdbc.core.JdbcTemplate">
                
                <property name="dataSource" ref="dataSource"></property>
       </bean>

   4、模板类的使用
       JdbcTemplate jdbcTemplate = (JdbcTemplate)
context.getBean("jdbcTemplate");
       String sql = "insert into user values(null,?,?)";
       int row = jdbcTemplate.update(sql, "白骨精",5000);
       System.out.println("影响的行数"+row);

       说明：模板类自动的会使用预编译的方式。保证数据的安全。
       使用预编译时参数用“？”代替。具体的参数赋值在执行模板方法时指定
       jdbcTemplate.update(sql, "白骨精",5000);
       所有的增删改操作都用jdbcTemplate.update(sql,arg0,arg1);

   5、JDBC模板类中的查询方法
       通常情况下查询的结果结通过List进行封装。每一个list中的元素都是一个对象（实体类对象），而原始的模板对象
       方法jdbcTemplate.queryForList(sql);返回一个List<Map<key,value>>的形式
这样不符合我们的习惯。并且处理起来很麻烦。

   6、说明
       虽然jdbcTemplate在使用上比jdbc原生的简单。可是在现实的开发中几乎不用。

   7、Spring的声明式的事务处理
       ★可以指定具体的方法来控制事务。例如增删改添加事务，而查询方法和其他方法都不需要事务。
       ★只要在Spring中使用了声明式的事务处理，将来所有的事务都不需要程序员自己维护。spring会非常智能帮你维护数据库事务。

       分析：
       问题：如果控制事务。
       专门的事务管理器。专门负责数据源的管理。

       步骤：
       ★修改配置文件的头
       ★配置事务管理器
       
           <bean id="transactionManager"
class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
                    <property name="dataSource" ref="dataSource"></property>
           </bean>
       ★配置事务通知
           
           <tx:method name="update*" propagation="REQUIRED"/>
           <tx:method name="find*" propagation="SUPPORTS" read-only="true"/>
           <tx:method name="*" propagation="SUPPORTS"/>
       ★配置切面
           <aop:config>
                    <aop:pointcut expression="execution(* service..*(..))"
id="pc"/>
                    <aop:advisor advice-ref="tx" pointcut-ref="pc"/>
           </aop:config>

   8、传播属性
       propagation="REQUIRED"
       propagation="SUPPORTS"
       实现事务的传播属性REQUIRED，可以做到多表操作时事务的一致性。
       propagation="SUPPORTS"
       如果一直操作有事务。那么当执行find()时，这个方法也会添加事务。

   9、事务的回滚策略
       ★当程序执行遇到运行时异常时事务会回滚。
       ★当程序执行遇到检查异常时事务不会回滚
       ★修改回滚策略
       rollback-for="java.sql.SQLException" 遇到那种异常事务回滚
       no-rollback-for="java.lang.Exception" 遇到所有的异常都不回滚

热门工具换一换