栏目分类:
子分类:
返回
名师互学网用户登录
快速导航关闭
当前搜索
当前分类
子分类
实用工具
热门搜索
名师互学网 > IT > 软件开发 > 后端开发 > Java

Spring从0开始最全面详解

Java 更新时间: 发布时间: IT归档 最新发布 模块sitemap 名妆网 法律咨询 聚返吧 英语巴士网 伯小乐 网商动力

Spring从0开始最全面详解

Spring从0开始最全面详解 1、spring的概述
  1. spring是什么?

    ​ Spring是分层的Java SE/EE应用 full-stack 轻量级开源框架,以IOC(Inverse Of Control :反转控制)和AOP(Aspect Oriented Programming :面向切面编程)为内核,提供了展现层Spring MVC 和持久层 Spring JDBC 以及业务层事务管理等众多的企业级应用技术,还能整合开源世界众多著名的第三框架和类库。

  2. spring的两大核心?
    ​ IOC 和 AOP

  3. spring的发展历程和优势
    ​ 优势:方便解耦,简化开发(利用了IOC容器)
    ​ AOP编程的支持
    ​ 声明事务的支持
    ​ 方便程序的测试
    ​ 方便集成各种优秀框架
    ​ 降低 JavaEE API 的使用难度
    ​ Java 源码是经典学习典范

  4. spring体系结构

2、程序的耦合及解耦
耦合:程序间的依赖关系
包括:
​		类之间的依赖
​		方法间的依赖
解耦:
​	降低程序间的依赖关系
实际开发中:
​	应该做到:编译期不依赖,运行期才依赖
解耦的思路:
​	第一步:使用反射来创建对象,而避免使用new 关键字。
​	第二步:通过读取配置文件来获取要创建的对象的全限定类名。
3、IOC概念和spring中的IOC
  1. IOC(控制反转):不用new对象了,用工厂来创建对象,控制权发生了反转
  2. IOC作用:削减计算机程序的耦合(解除代码中的依赖关系)
  3. 获取spring 的ioc核心容器,并根据id获取对象
    ​ ApplicationContext的三个常用实现类
    ​ 1.ClassPathXmlApplicationContext:它可以加载类路径下的配置文件,要求配置文件必须在类路径下。不在的话,加载不了。(更常用)
    ​ 2.FileSystemXmlApplicationContext:它可以加载磁盘任意路径下的配置文件(但是必须要有访问权限)
    ​ 3.AnnotationConfigApplicationContext:它是用于读取注解创建容器的
  4. 核心容器的两个接口引发的问题:
    ​ ApplicationContext:单例对象适用 一般采用此接口
    ​ 它在构建核心容器时,创建对象采用的策略是采用立即加载的方式,也就是说,只要一读取完配置文件马上就创建配置文件中配置的对象。
    ​ BeanFactory:多例对象适用
    ​ 它在构建核心容器时,创建对象采用的策略是采用延迟加载的方式。也就是说,什么时候根据id获取对象了,什么时候才真正的创建对象。
    //1.获取核心容器对象
    //ApplicationContext ac = new FileSystemXmlApplicationContext("D:\bean.xml");(绝对)
    ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
    //2.根据id获取Bean对象
    UserService service = (UserService) ac.getBean("userService");
    UserDao dao = ac.getBean("userDao",UserDao.class);
    
    System.out.println(service);
    System.out.println(dao);
    
spring中基于XML的IOC环境搭建,基于spring在xml中的配置
  1. 创建bean对象的三种方式:

    
    
    
    	
        
        
            
        
        
    
        
        
        
         
    
        
    	 得到InstanceFactory对象
      	  调用里面的方法
    
          
        
    
    
  2. bean对象的作用范围:

    
        
    
  3. bean对象的生命周期:


    
依赖注入(Dependency Injection)
  1. 依赖关系的 管理:
    以后都交给spring来维护。
    在当前类需要用到其他类的对象,由spring为我们提供,我们只需要在配置文件中说明。
  2. 依赖关系的维护:
    就称之为依赖注入。
  3. 依赖注入:
    能注入的数据:
    1. 基本类型和String
    2. 其他bean类型(在配置文件中或者注解配置过的bean)
    3. 复杂类型
    ​ 注入的方式:
    1. 使用构造函数提供
    2. 使用set方法提供
    3. 使用注解提供

    
       
        
        
        

    

    
        

     
    
        
        
        
    
spring基于注解的IOC以及ioc的案例
  1. spring中ioc的常用注解

    
    @Component(value = "userService")
    public class UserServiceImpl implements UserService {
        @Autowired
        private UserDao userDao2 = null;
    }
    
    @Repository
    public class UserDaoImpl implements UserDao {
        
    }
    @Repository(value = "userDao2")
    public class UserDaoImpl2 implements UserDao {
        
    }
    
    //使用Qualifier时,两个必须一起使用
    //@Autowired
    //@Qualifier("userDaoImpl")
    
    @Resource(name = "userDaoImpl")
    private UserDao userDao2 = null;
    
         
    @Component(value = "userService")
    @Scope("prototype")
    public class UserServiceImpl implements UserService {
        @Override
        @PostConstruct
        public void init() {
            System.out.println("我初始化了...");
        }
    
        @Override
        @PreDestroy
        public void destroy() {
            System.out.println("我销毁了...");
        }
    }
    
     	@Value(value = "${driver}")
        private String driver;
        
        @Value("username")
        private String username;
    
  2. 改造基于注解的ioc案例,使用纯注解的方式实现

    @Configuration
    @ComponentScan("com.lucky")  //要扫描的包
    public class ConfigReplaceXml {
    }
    

    ​ 注意:ComponentScan扫描时,只会扫描有 @Configuration 注解的类

    Configuration细节:当配置类作为AnnotationConfigApplicationContext对象创建的参数时,该注解可以不写。

     
    	@Bean
        @Scope("prototype")
        public QueryRunner createQueryRunner(DataSource dataSource){
            return new QueryRunner(dataSource);
        }
    
        @Bean
        public DataSource createDataSource(){
            try{
                ComboPooledDataSource dataSource = new ComboPooledDataSource();
                dataSource.setDriverClass("com.mysql.cj.jdbc.Driver");
                dataSource.setJdbcUrl("jdbc:mysql://localhost:3306/test");
                dataSource.setUser("root");
                dataSource.setPassword("root");
                return dataSource;
            }catch (Exception e){
                throw new RuntimeException(e);
            }
    
        }
    
    @Test
    public void test2(){
    	ApplicationContext ac = new AnnotationConfigApplicationContext(ConfigReplaceXml.class);  //创建方式改变,基于注解创建
        QQUserService service = ac.getBean("userService",QQUserService.class);
        QQUser one = service.findOne(2);
        System.out.println(one);
    }
    		  
    

    ​ @Bean注解的细节:细节: 当我们使用注解配置方法时,如果方法有参数,spring框架会去容器中查找有没有可用的bean对象,没有就会报错

    ​ (1).实现配置类调用另一配置类的方法:

    //第一种
    @ComponentScan({"com.lucky"})
    public class ConfigReplaceXml {
    }
    
    @Configuration
    public class JDBCConfig {
    }
    
    ApplicationContext ac = new AnnotationConfigApplicationContext(ConfigReplaceXml.class);
    
    //第二种
    @ComponentScan({"com.lucky"})
    public class ConfigReplaceXml {
    }
    
    public class JDBCConfig {
    }
    ApplicationContext ac = new AnnotationConfigApplicationContext(ConfigReplaceXml.class, JDBCConfig.class);//两个类都加上,为兄弟关系
    
    //第三种(具有父子关系)
    @ComponentScan({"com.lucky"})
    @Import(value = {JDBCConfig.class})
    public class ConfigReplaceXml {
    }
    
    ApplicationContext ac = new AnnotationConfigApplicationContext(ConfigReplaceXml.class);
    

    ​ (2)配置连接数据库的资源文件

    driver=com.mysql.cj.jdbc.Driver
    url=jdbc:mysql://localhost:3306/test
    user=root
    password=root
        
    @ComponentScan({"com.lucky"})
    @Import(value = {JDBCConfig.class})
    @PropertySource("classpath:jdbcConfig.properties")
    public class ConfigReplaceXml {
    }
    
    	@Value(value = "${driver}")
        private String driver;
        @Value(value = "${url}")
        private String url;
        @Value("${user}")
        private String username;
        @Value("${password}")
        private String password;
    

    ​ (3)在注解中springIOC容器中同一个对象有多个实现方法时

    @Bean
    @Scope("prototype")
    public QueryRunner createQueryRunner(@Qualifier(value = "ds1") DataSource dataSource){
        return new QueryRunner(dataSource);
    }
    
    @Bean(name = "ds1")
        public DataSource createDataSource(){}
    
    @Bean(name = "ds2")
        public DataSource createDataSource2(){}
    
4、动态代理的两种方式

1、动态代理(基于接口实现)

Huawei huawei = new HuaWei();
Producer proxyProducer = (Producer) Proxy.newProxyInstance(huaWei.getClass().getClassLoader(), huiWei.getClass().getInterfaces(), new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                //增强代码
                Object returnValue = null;
                //1.获取方法执行的参数
                double money = (double) args[0];
                //2.判断当前方法是不是销售
                if("saleProduce".equals(method.getName())){
                    //若是销售的方法名,则要进行处理,代理商要拿到 20%,生产商只能拿到 80%
                    returnValue = method.invoke(huaWei, money * 0.8);
                }
                return returnValue;
            }
        });
        proxyProducer.saleProduce(10000);
  1. 动态代理另一种实现方式(基于子类)
Huawei huawei = new HuaWei();
Producer cglibProducer = (Producer) Enhancer.create(huaWei.getClass(), new MethodInterceptor() {
            
            @Override
            public Object intercept(Object proxy, Method method, Object[] ags, MethodProxy methodProxy) throws Throwable {
                //增强代码
                Object returnValue = null;
                //1.获取方法执行的参数
                double money = (double) ags[0];
                //2.判断当前方法是不是销售
                if ("saleProduce".equals(method.getName())) {
                    //若是销售的方法名,则要进行处理,代理商要拿到 20%,生产商只能拿到 80%
                    returnValue = method.invoke(huaWei, money * 0.8);
                }
                return returnValue;
            }
        });
        cglibProducer.saleProduce(12000);
5、AOP

​ AOP:Aspect Oriented Programing(面向切面编程)。

spring中基于XML的AOP配置
spring中基于XML的 AOP 配置步骤
     1.把通知 bean 也交给 spring 来管理
     2.使用 aop:config 标签表明开始aop配置
     3.使用 aop:aspect 标签表明配置切面
         id属性  : 是给切面提供一个唯一标识
         ref属性 : 是指定通知类的 id
     4.在 aop:aspect 标签内部使用对应标签来配置通知的类型
         我们现在实例是让 printLog 方法在切入点方法执行之前执行,所以是前置通知
         aop:before : 表示配置前置通知
             method属性:用于指定Logger类中哪个方法是前置通知
             pointcut属性:用于指定切入点表达式,该表达式的含义指的是对业务层中哪些方法的增强
		切入点表达式的写法:
                    关键字:execution(表达式)
                    表达式:
                        访问修饰符 返回值 包名.包名.包名...类名.方法名.(参数列表)
                    举例:
                        public void com.lucky.service.impl.AccountServiceImpl.save()

                修饰符可以不写:
                    void com.lucky.service.impl.AccountServiceImpl.save()
                返回值可以使用通配符,表示任意返回值:
                    * com.lucky.service.impl.AccountServiceImpl.save()
                包名可以使用通配符,表示任意包。但是有几级包,就需要写几个 *.
                    void *.*.*.*.AccountServiceImpl.save()
                包名可以使用 .. 表示当前包及其子包:
                    void *..AccountServiceImpl.save()
                类名和方法名都可以使用 * 来通配
                    * *..*.*()
                参数列表:
                    可以直接写数据类型:
                        基本类型直接写名称      int
                        引用类型写包名.类名的方式 java.lang.String
                    可以使用通配符表示任意的类型,但是必须有参数
                    可以使用 .. 表示有无参数均可,有参数可以是任意类型
                全通配符写法:
                    * *..*.*(..)

                实际开发中切入点表达式的通常写法 :
                    切到业务层实现类下的所有方法
                        * com.lucky.service.impl.*.*(..)
        
			

            

            

            


            


            


            

四种常用的通知类型
method:指定一个类中的方法   pointcut:指定切入点表达式,该表达式的含义指的是对业务层中哪些方法的增强












配置通用表达式



环绕通知
//invoke方法执行的就是环绕通知

public Object aroundPrintLog(MethodInvocationProceedingJoinPoint pjp){
    System.out.println("环绕通知:打印aroundPrintLog...");
    return null;
}
基于注解的AOP

使用注解时:
XML中要配置:
@Aspect放在类上:表示当前类是一个切面类

6、事务控制 1、基于XML配置



 




 
 
     
     
     
 




 
 
 
 

2、基于注解配置
 
    

    
        
    

    
        
        
        
        
    

    
    
    
        
    

    
    
@Service("accountService")
//@Transactional   //需要事务支持
@Transactional(propagation = Propagation.SUPPORTS, readOnly = true)  //对里面的全部方法配置针对查询的只读形式
public class AccountServiceImpl implements AccountService {

    @Autowired
    private AccountDao accountDao;

    @Override
    public Account findAccountById(int id) {
        return accountDao.findAccountById(id);
    }

    @Override
    @Transactional(propagation = Propagation.REQUIRED, readOnly = false)  //只对该方法针对增删改查的读写形式
    public void transfer(String sourceName, String targetName, double money) {}
转载请注明:文章转载自 www.mshxw.com
本文地址:https://www.mshxw.com/it/956136.html
我们一直用心在做
关于我们 文章归档 网站地图 联系我们

版权所有 (c)2021-2022 MSHXW.COM

ICP备案号:晋ICP备2021003244-6号