Spring入门

最新推荐文章于 2024-04-22 12:13:05 发布
最新推荐文章于 2024-04-22 12:13:05 发布
阅读量123 收藏
点赞数
分类专栏： Spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43891731/article/details/88926417
版权

Spring

下载
  1. 下载Spring包:spring下载
  2. 导包:
    1. spring-beans-4.1.0.RELEASE.jar
    2. spring-context-4.1.0.RELEASE.jar
    3. spring-core-4.1.0.RELEASE.jar
    4. spring-expression-4.1.0.RELEASE.jar
  3. 下载相关依赖包
    • commons-logging-1.1.1.jar
IOC
  1. IOC对象相关参数
    1. scope=“prototype” 多例 得到ICO容器后什么时候用什么时候创建
    2. scope=“singleton” 单例 在得到IOC容器之前就已经创建好了
    3. init-method=“init” 对象在创建的时候执行的初始化方法
    4. destroy-method=“destroy” 对象在销毁的时候执行的销毁方法
    5. lazy-init=“true” 延迟加载 true=延迟| false=不延迟 default=false
  2. IOC对象创建
    1. 无参构造方法
       <bean id="user1" class="pojo.User"></bean>
    2. 有参构造方法
      1. 普通赋值
        <bean id="user2" class="pojo.User">    <property name="id" value="2"></property>    <property name="username" value="李四"></property></bean>
      2. set赋值
           <bean id="user3" class="pojo.User">                       <constructor-arg value="1">                                     </constructor-arg>  
    <constructor-arg value="张三">                            </constructor-arg></bean>
    3. 工厂方法
      1. 静态工厂方法
        <bean id="user5" class="factory.Dfactory" factory-method="b"></bean>
      2. 普通工厂方法
        <bean id="c" class="factory.Dfactory"></bean><bean id="user4" factory-bean="c" factory-method="a"></bean>

Construct Injection 依赖注入

  1. set注入
    1. 普通方法
      <!--外部注入-->
<bean id="userDao" class="com.Spring.dao.impl.UserDaoImpl">
 </bean>
 <bean id="userService" class="com.Spring.service.impl.UserServiceImpl">   
 <property name="userDao" ref="userDao"></property></bean>
<bean id="userAction" class="com.Spring.controller.UserAction">   
 <property name="userService" ref="userService"></property></bean>
    2. 内部嵌套
          <!--内部注入-->
    <bean id="userAction" class="com.Spring.controller.UserAction">                         <property name="userService">     
              <bean class="com.Spring.service.impl.UserServiceImpl">        
                <property name="userDao">      
                    <bean class="com.Spring.dao.impl.UserDaoImpl">                                      </bean>            
                </property>       
           </bean>    
        </property>
   </bean>
    3. p命名空间
      • 引入xmlns:p="http://www.springframework.org/schema/p"
       <!--p命名空间注入-->
 <bean id="userDao" class="com.Spring.dao.impl.UserDaoImpl">                    </bean>
 <bean id="userService" class="com.Spring.service.impl.UserServiceImpl" p:userDao-ref="userDao"></bean>
 <bean id="userAction" class="com.Spring.controller.UserAction" p:userService-ref="userService"></bean>
    4. 自动装配:
      1. byName
          <!--自动装配 byName --> 
  <bean id="userDao" class="com.Spring.dao.impl.UserDaoImpl"></bean>    
  <bean id="userService" class="com.Spring.service.impl.UserServiceImpl" autowire="byName"></bean>    
  <bean id="userAction" class="com.Spring.controller.UserAction" autowire="byName"></bean>
      2. byType
            <!--自动装配 byType -->
    <bean id="userDao" class="com.Spring.dao.impl.UserDaoImpl">     </bean>
    <bean id="userService" class="com.Spring.service.impl.UserServiceImpl" autowire="byType">
    </bean>
    <bean id="userAction" class="com.Spring.controller.UserAction" autowire="byType"></bean>
  2. 注解
    1. 需要环境: 帮助文档搜索xmlns:context
        xmlns:context="http://www.springframework.org/schema/context"
  http://www.springframework.org/schema/context
 http://www.springframework.org/schema/context/spring-context.xsd
      1. @Repository : dao层
      2. @Service : service层
      3. @Controller : controller层
      4. @Component : 普通注解
      5. @Resource : 对象注解

AOP

  1. 代理 参考博客:三种代理模式
    • 接口
    ```java
    package com.Spring.test;
    /** 
    * @Author Jamin <br> 
    *  @Date 2019/3/26 15:43 <br> 
    * @Description 接口 
    */public interface SALE {  String sale(int money);}
 ```

    • 实现类

          package com.Spring.test;
    /** 
    * @Author Jamin <br> 
    * @Date 2019/3/26 15:44 <br> 
    * @Description * 目标对象 
    * */
    public class Apple{  public String sale(int money)          {      
    return "卖苹果手机";  }}
      1. 静态代理: 因为代理对象需要与目标对象实现一样的接口,所以会有很多代理类,类太多.同时,一旦接口增加方法,目标对象与代理对象都要维护.
       package com.Spring.test;

    /**
    * @Author Jamin <br>
    * @Date 2019/3/26 15:47 <br>
    * @Description
    *
    *
    * 静态代理
    */
    public class AppleProxy implements SALE {
        private Apple apple = new Apple();
        public AppleProxy(Apple apple) {
            this.apple = apple;
        }

        @Override
        public String sale(int money) {

            String s=apple.sale(money);
            String a="买手机送手机壳";
            return s+a;
        }
    }
      1. 动态代理 需要给出代理对象的类型 需要给出代理对象接口的类型
             package com.Spring.test;

   import java.lang.reflect.InvocationHandler;
   import java.lang.reflect.Method;
   import java.lang.reflect.Proxy;

   /**
   * @Author Jamin <br>
   * @Date 2019/3/26 16:19 <br>
   * @Description
   */
   public class SaleFactory {
   private Object o;

   public SaleFactory(Object o) {
       this.o = o;
   }

   public Object factory() {
       return Proxy.newProxyInstance(
           o.getClass().getClassLoader(),
           o.getClass().getInterfaces(),
           new InvocationHandler() {
           /**
           *
           * @param proxy 被代理的对象
           * @param method  要调用的方法
           * @param args   方法调用时所需要的参数
           */
           @Override
           public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
               System.out.println("aaaaaaaaaaaaaaa");
               Object invoke = method.invoke(o, args);
               System.out.println("bbbbbbbbbbbbbbb");
               return invoke;
           }
           });
   }
   }
      1. Cglib代理 子类代理
            package com.Spring.test;

import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;

/**
* @Author Jamin <br>
* @Date 2019/3/26 17:15 <br>
* @Description
*/
public class Cglib implements MethodInterceptor {
private Object o;

public Cglib(Object o) {
    this.o = o;
}

public Object getProxy() {
    Enhancer en = new Enhancer();
    en.setSuperclass(o.getClass());
    en.setCallback(this);
    return en.create();
}

@Override
public Object intercept(Object obj, Method method, Object[] objects, MethodProxy methodProxy)
    throws Throwable {
    System.out.println("aaaaaaaaaaaaa");
    Object invoke = method.invoke(o, objects);
    System.out.println("bbbbbbbbbbbb");
    return invoke;
}
}
  2. AOP

    1. 概念:

      1. 是一种编程范式,不是一种编程语言
      2. 解决特定问题,不是解决所有问题
      3. 是OOP的补充,不是替代

    2. 好处:

      1. 集中处理某一关注点/横切逻辑
      2. 方便添加/删除关注点
      3. 侵入性少,增强代码可读性及可维护性

    3. 应用场景

      1. 权限控制
      2. 缓存控制
      3. 事务控制
      4. 审计日志
      5. 性能监控
      6. 分布式追踪
      7. 异常处理

    4. 名词解释

      1. 连接点
        • 目标对象中所有可以增强的方法
      2. 切入点
        • 目标对象中已经增强的方法
      3. 目标对象Target
        • 代理的目标对象(被代理的对象)
      4. 通知
        1. 目标方法在切面运行时的方法
        2. 通知类型
          1. 前置通知(before)
          2. 后置通知(after)
          3. 异常通知(after-throwing)
          4. 返回通知(after-returning)(异常不会执行)
          5. 环绕通知(around)
      5. 织入Weaving
        • 将通知应用到切入点的过程
      6. 代理Proxy
        • 将通知织入到目标对象之后形成的代理

    5. 使用

      1. 导包
        • com.springsource.org.aopalliance-1.0.0.jar
        • com.springsource.org.aspectj.weaver-1.6.8.RELEASE.jar
        • spring-aspects-4.1.0.RELEASE.jar
      2. 创建目标对象
      3. 创建通知对象
      4. 将对象织入到目标对象中
      5. 配置切入点
      6. 指定通知

    6. 代码

      1. 第一种方式
        1. 配置文件
          <!--创建目标对象-->
<bean id="empServiceImpl" class="com.spring.EmpService.EmpServiceImpl"></bean>
<!--创建代理对象-->
<bean id="empAop" class="com.spring.aop.EmpAop"></bean>               
<!--将对象织入目标对象中-->
<aop:config>
<!--配置切入点-->
    <aop:pointcut id="pt" expression="execution(* com.spring.EmpService.EmpServiceImpl.*())"></aop:pointcut>
<!--指定通知-->
    <aop:aspect ref="empAop">
    <aop:before method="getBefore" pointcut-ref="pt"></aop:before>
    <aop:after method="getAfter" pointcut-ref="pt"></aop:after>
    <aop:around method="getRound" pointcut-ref="pt"></aop:around>
    <aop:after-returning method="getReturn" pointcut-ref="pt"></aop:after-returning>
    <aop:after-throwing method="getThrowable" pointcut-ref="pt"></aop:after-throwing>
    </aop:aspect>
</aop:config>
        2. 方法
               package com.spring.aop;

    import org.aspectj.lang.ProceedingJoinPoint;

    /**
    * @Author Jamin <br>
    * @Date 2019/3/27 10:22 <br>
    * @Description
    */
    public class EmpAop {

    /** 前置通知 */
    public void getBefore() {
        System.out.println("前置通知");
    }
    /*后置通知*/
    public void getAfter() {
        System.out.println("后置通知");
    }
    /*环绕通知*/
    public Object getRound(ProceedingJoinPoint pj) throws Throwable {
        System.out.println("环绕通知前");
        Object proceed = pj.proceed();
        System.out.println("环绕通知后");
        return proceed;
    }
    /*返回通知*/
    public void getReturn() {
        System.out.println("返回通知");
    }
    /*异常通知*/
    public void getThrowable() {
        System.out.println("异常通知");
    }
    }
      2. 第二种方式 注解配置
        1. 配置文件
            <!--创建目标对象-->
  <bean id="empServiceImpl" class="com.spring.EmpService.EmpServiceImpl"></bean>
  <!--创建代理对象-->
  <bean id="empAop2" class="com.spring.aop.EmpAop2"></bean>
  <!--开启自动代理-->
  <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
        2. 方法
                        package com.spring.aop;

  import org.aspectj.lang.ProceedingJoinPoint;
  import org.aspectj.lang.annotation.*;
  import org.springframework.core.annotation.Order;

  /**
  * @Author Jamin <br>
  * @Date 2019/3/27 14:02 <br>
  * @Description
  */
  @Aspect
  public class EmpAop2 {
  @Pointcut("execution(* com.spring.EmpService.EmpServiceImpl.*())")
  public void pointCut() {}

  /** 前置通知 */
  @Before("pointCut()")
  public void getBefore() {
      System.out.println("前置通知");
  }

  /*返回通知*/
  @AfterReturning("pointCut()")
  public void getReturn() {
      System.out.println("返回通知");
  }
  /*后置通知*/
  @After("pointCut()")
  public void getAfter() {
      System.out.println("后置通知");
  }
  /*环绕通知*/
  @Order(2)
  @Around("pointCut()")
  public Object getRound(ProceedingJoinPoint pj) throws Throwable {
      System.out.println("环绕通知前");
      Object proceed = pj.proceed();
      System.out.println("环绕通知后");
      return proceed;
  }
  /*异常通知*/
  @AfterThrowing("pointCut()")
  public void getThrowable() {
      System.out.println("异常通知");
  }
  }

Spring中的事务

  1. 事务的概念
    • 事务是逻辑上的一组操作,要么都执行,要么都不执行
  2. 事物的特征
    • 原子性:事务是最小的执行单位，不允许分割。事务的原子性确保动作要么全部完成，要么完全不起作用；
    • 一致性:执行事务前后，数据保持一致；
    • 隔离性:并发访问数据库时，一个用户的事物不被其他事物所干扰，各并发事务之间数据库是独立的；
    • 持久性: 一个事务被提交之后。它对数据库中数据的改变是持久的，即使数据库发生故障也不应该对其有任何影响。
  3. 并发事务带来的问题
    1. 脏读[Dirty read] : 当一个事务正在访问数据并对事务进行了修改但并未提交,另一个事务也访问这条数据并使用了这条脏数据
    2. 丢失修改:两个事务同时访问一条数据并进行修改,第一个事务的修改结果就丢失了
    3. 不可重复读:一个事务多次读同一个数据,还没有结束时,第二个事务修改了这条数据导致第一个事务读到的数据不一致
    4. 幻读: 一个事务读取了几条数据,第二个事务添加了几条数据,导致第一个事务在随后的查询中发现了一些不存在的数据
      • 与不可重复读的区别:不可重复读的重点在修改,幻读的重点在于新增和删除
  4. 解决读的问题
    • 设置隔离级别
  5. Spring事务处理:声明式事务处理
    1. xml形式
      <!-- 定义事务管理器 -->
<bean id="transactionManager"
    class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="dataSources"/>
</bean>
<!--配置事务通知-->
<tx:advice id="txadvice" transaction-manager="transactionManager">
    <!--事务操作-->
    <tx:attributes>
        <tx:method name="account*"/>
    </tx:attributes>
</tx:advice>
<!--切面配置-->
<aop:config>
    <!--切入点service层的实现方法-->
    <aop:pointcut id="pt" expression="execution(* com.springmvc.*())"/>
    <!--切面-->
    <aop:advisor advice-ref="txadvice" pointcut-ref="pt"></aop:advisor>
</aop:config>
    2. 注解
               <!-- 定义事务管理器 -->
 <bean id="transactionManager"
     class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
     <property name="dataSource" ref="dataSources"/>
 </bean>
 <!--开启注解事务管理-->
 <tx:annotation-driven transaction-manager="transactionManager"></tx:annotation-driven>
 <!--在需要事务管理的方法上添加注解 @Transactional-->
Jamin_Ye
关注
专栏目录
spring入门
那个有故事又努力的人啊
10-27 121
先看下这个图 ,这个框架分成6大类模块,我们只需要关注spring核心容器这个模块 spring模块他需要beans,core,context,expression包 要得到这个包需要到这里下载开发包 spring目录下有很多版本,一般我们选择最新版,往下找最新版 下载解压 docs:spring的使用教程都在这里 libs:spring框架需要用到的jar 如果只是简单...
Spring入门教程
weixin_58642210的博客
12-12 1876
目录 工厂模式 1.什么是框架？ 2.Spring的优势 3.举个User小例子 IOC控制反转 beans 单例模式 工厂模式 把原来分布在各个地方的对象创建的过程都单独抽离出来，统一交给工厂类来负责所需对象的创建 1.什么是框架？ 1.1框架本身一般不完整 1.2在里面进行填充扩展，迎合公司的业务需求，做公司的项目 1.3为了更好的适合大多数项目，不断进行扩展，扩充的东西就是类库 2.Spring的优势 2.1方便解耦，简化开发 Spring就是一个大工厂，可以将所有..
JAVA之Spring入门导读
最新发布
tq02的博客
04-22 1422
详细介绍Spring是什么，以及学习路线
Spring入门第一讲——Spring框架的快速入门
热门推荐
李阿昀的博客
04-08 14万+
Spring的概述什么是Spring据度娘所载： Spring是一个开源框架，Spring是于2003年兴起的一个轻量级的Java开发框架，由Rod Johnson创建。简单来说，Spring是一个分层的JavaSE/EEfull-stack(一站式)轻量级开源框架。 Spring是一个开源框架，Spring是于2003年兴起的一个轻量级的Java开发框架，由Rod Johnson在其著作Exp
Spring入门程序
weixin_54013954的博客
12-11 1097
spring是当前主流的JavaWeb框架，它是为了解决应用开发复杂性问题而产生的。对于一个Java应用程序员来说，掌握spring框架的使用，是我们基本的一项技能。
@RequestParam使用defaultValue属性设置默认值
weixin_43891731的博客
06-19 2327
@RequestParam使用defaultValue属性设置默认值 注意设置必须是string类型的，框架自己会做转换 参考 @RequestParam使用defaultValue属性设置默认值
springboot设置文件上传限制
weixin_43891731的博客
11-15 1471
参考springboot最大上传文件配置 package com.ustcinfo.fn.config; import org.springframework.beans.factory.annotation.Value; import org.springframework.boot.web.servlet.MultipartConfigFactory; import org.springframework.context.annotation.Bean; import org.springframew
idea配置多环境打包
weixin_43891731的博客
05-23 906
4个配置文件 src/main/resource/application.properties src/main/resource/application-dev.properties src/main/resource/application-release.properties src/main/resource/application-test.properties 配置pom.xml <profiles> <profile> .
springboot静态资源添加版本号控制版本更新
weixin_43891731的博客
06-19 678
解决方法 spring.resources.chain.strategy.fixed.enabled=true spring.resources.chain.strategy.fixed.paths=/** spring.resources.chain.strategy.fixed.version=@project.version@ 验证结果 参考文档 1. Springboot2 thymeleaf 静态资源加版本号控制缓存更新 ...
springboot非web项目启动
weixin_43891731的博客
07-05 498
一直挂着@SpringBootApplication public class XxlJobDemoApplication { public static void main(String[] args) throws InterruptedException { SpringApplication.run(XxlJobDemoApplication.class, args); //让程序不结束 new CountDownLatch(1).await(); } } 实现Applicat.
SpringIOC源码流程图
weixin_43891731的博客
06-06 423
Spring最重要的内容就是IOC和AOP,AOP在实际中用的比较少,但接触过Spring的人我相信都用过Spring的IOC,我们每天都在用的东西,到底底层原理是怎么样的,看源码跟着这张图你就能明白
全局参数去除空格
weixin_43891731的博客
11-07 395
package com.ustcinfo.fn.config; import org.springframework.beans.propertyeditors.CustomDateEditor; import org.springframework.beans.propertyeditors.StringTrimmerEditor; import org.springframework.web.bind.WebDataBinder; import org.springframework.web.bind
单例中注入多例
weixin_43891731的博客
08-03 371
单例中注入多例 在配置多例对象时加入 <aop:scoped-proxy/> <bean id="excelListener" class="com.app.zrr.util.ExcelListener" scope="prototype"> <aop:scoped-proxy/> </bean>
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Jamin_Ye

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值