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

Spring

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

Spring

Spring Spring概念 轻量级的开源javaEE框架

轻量级,引入的jar包小。不依赖与其他的组件自己可以单独使用。

可以解决开发的复杂性

两个核心

IOC:控制反转,把创建对象过程交给Spring进行管理。

AOP:面向切面,不修改源代码进行功能增强。

Spring特点:

方面结构,简化开发

Aop编程支持

方面程序测试

可以整个其他各种框架。

方便事务操作。

入门案例
Name:spring
Repository Path:release/org/springframework/spring/
URL to file:https://repo.spring.io/artifactory/release/org/springframework/spring/
Created:30-09-19 09:06:32 +00:00
实施:

spring最基本的四个组成部分beans、context、core、expression,这四个基本包。

在使用时需要在增加commons-logging.jar文件;如果没有logging包的话,@test不能使用。

package com.company.testdemo;
import com.company.User;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class TestSpring5 {
//如果没有logging包的话,@test不能使用
    @Test
    public void testAdd(){
        //1 加载spring配置文件
        ApplicationContext context=
                new ClassPathXmlApplicationContext("bean1.xml");
        //2 获取配置创建的对象
        User user=context.getBean("user", User.class);
        System.out.println(user);
        user.add();

    }
}
package com.company;

public class User {
    public void add(){
        System.out.println("add...........");
    }
}




    

IOC 什么是IOC

控制反转,把对象创建和对象之间的调用过程,交给spring进行管理。使用IOC的目睹是为了耦合度的降低。做的入门案例就是IOC的实现。

IOC的底层原理:

xml解析、工厂模式,反射

说明

当前有两个类分别叫UserService{execute(){}}和UserDao{add(){}},例如当前execute方法要调用add方法,传统的方法是在execute方法中new一个UserDao然后调用add方法,这个方法耦合度太高,如dao的路径变化了execute里面的调用也需要变化。*可以使用工厂模式:再增加一个UserFactory工厂类在工厂类中设置一个public static UserDao getDao(){return new UserDao()};方法。这是在execute方法中可以通过工厂类的getDao方法进行add方法的调用。**但是此时还是有比较高的耦合度的。但是相对于原始方法要好。**而IOC则可以是耦合度更低。

IOC: IOC过程:

第一步:xml配置文件


    

第二步:有service类和dao类,创建工厂类

class UserFactory{
    public static UserDao getDao(){
    	String classValue=classs属性值;//1、xml解析
        Class clazz=Class.forName(classsValue);//2 通过反射创建对象
        return (UserDao)clazz.newInstance();
    }
}
IOC接口:

IOC思想基于IOC容器完成,IOC容器底层就是对象工厂。Spring提供IOC容器实现两种方式:(两个接口)BeanFactory和ApplicationContext

BeanFactory:IOC容器基本实现,是Spring内部的使用接口,不提供开发人员进行使用。加载配置文件的时候不会创建对象,在获取对象(使用)才去创建对象

ApplicationContext:BeanFactory接口的子接口,提供更多更强大的接口,提供更多更强大的功能,一般由开发人员进行使用。加载配置文件时候会把在配置文件对象进行创建。在服务器启动的时候就创建,而不是在操作的时候创建。

ApplicationContex接口有实现类。

IOCbean管理 什么是bean管理:

spring创建对象,spring注入属性。

bean管理有两种操作方式:

基于xml配置文件方式实现。

基于注解方式实现。

IOC操作bean管理
  1. 基于xml方式创建对象
    1. 在spring配置文件中使用bean标签,标签中添加对应的属性就可以实现对象创建。
    2. 在bean标签中有很多属性:
      1. id属性:给class对象取一个别名以作为唯一的标识
      2. class属性:类的全路径(包类路径)
    3. 创建对象时候默认也是执行无参数构造方法完成对象创建
  2. 基于xml方式注入属性
    1. DI:以来注入,注入属性。

      1. 使用set方法进行注入

        1. 创建类:定义属性和对应的set方法。

          package com.company;
          
          
          public class Book {
          //    public Book(String bname) {
          //        this.bname = bname;
          //    }
              private String bname;
              private String bauthor;
          
              public void setBname(String bname) {
                  this.bname = bname;
              }
              public void setBauthor(String bauthor) {
                  this.bauthor = bauthor;
              }
          
          public void testDemo(){
              System.out.printf(bname+"::"+bauthor);
              }
          }
          
        2. 在spring配置文件配置对象创建,配置属性注入

          
              
          
                  
                  
              
          
        3. 测试

          @Test
          public void testBook1(){
              //1 加载spring配置文件
              ApplicationContext context=
                      new ClassPathXmlApplicationContext("bean1.xml");
              //2 获取配置创建的对象
              Book book=context.getBean("book", Book.class);
              System.out.println(book);
              book.testDemo();
          }
          

        有参构造注入(快捷键alt+ins)

      2. 在spring配置文件中进行配置

        
            
                
                
            
        
    2. p名称空间注入(了解)

      1. 使用p名称空间注入,可以简化基于xml配置方式

        1. 第一步;添加p 名称空间在配置文件中
        
        

        第二步进行属性注入,在bean标签中进行操作

          
        
  3. IOC操作bean管理(xml注入其他类型属性)
    1. 字面量:null值

          
      
              
              
      
              
          
      
    2. 注入属性外部bean

      1. 创建两个类service类和dao类。

        package com.company.dao;
        
        public class UserDaoImpl implements UserDao {
        
            @Override
            public void upadd() {
        
                System.out.println("dao updata...........");
            }
        }
        
      2. 在service调用到里面的方法。

        package com.company.service;
        
        import com.company.dao.UserDao;
        import com.company.dao.UserDaoImpl;
        
        public class UserService {
        
            private UserDao userDao;
            public void setUserDao(UserDao userDao){
                this.userDao=userDao;
            }
        
            public void add(){
                System.out.println("service add...........");
        
                userDao.upadd();
        
        //原始方式:创建UserDao对象
        //        UserDao userDao = new UserDaoImpl();
        //        userDao.upadd();
            }
        }
        
      3. 在Spring配置文件中进行配置。

        
        
        
            
            
        
                
            
        
            
        
        
        

        测试

        @Test
            public void testAdd(){
                //1、加载spring配置文件
                ApplicationContext context=new ClassPathXmlApplicationContext("bean2.xml");
                //2、获取配置创建的对象
                UserService userService=context.getBean("userService", UserService.class);
                userService.add();
            }
        
    3. 注入属性-内部bean

      1. 一对多关系:部门和员工

        package com.company.bean;
        
        public class Dept {
            private String dname;
        
            public void setDname(String dname) {
                this.dname = dname;
            }
            @Override
            public String toString() {
                return "Dept{" +
                        "dname='" + dname + ''' +
                        '}';
            }
        }
        
      2. 一个部门有多个员工一个员工属于一个部门。部门是一,员工是多

        package com.company.bean;
        
        
        public class Emp {
            private String ename;
            private String genter;
        //员工属于某一个部门,使用对象形式表示
            private Dept dept;
            public void setEname(String ename) {
                this.ename = ename;
            }
        
            public void setGenter(String genter) {
                this.genter = genter;
            }
        
            public void setDept(Dept dept) {
                this.dept=dept;
            }
        
            public void add(){
                System.out.printf(ename+"::"+genter+"::"+dept);
            }
        }
        
      3. 在实体类之间表示一对多关系

      4. 在Spring配置文件中进行配置。

        
        
        
        
            
        
                
                
        
                
                    
                        
                    
                
            
        
        

        测试

        @Test
        public void testBean3(){
            //1、加载spring配置文件
            ApplicationContext context=new ClassPathXmlApplicationContext("bean3.xml");
            //2、获取配置创建的对象
            Emp emp = context.getBean("emp",Emp.class);
            emp.add();
        }
        
    4. 注入属性:级联赋值

      更改Spring配置文件

      1. 写法1

        
        
            
            
            
            
            
        
         
        
      2. 写法二:需要在emp类中增加getdept方法

        
        
            
            
            
            
            
            
        
        
        
        public void setDept(Dept dept) {
            this.dept=dept;
        }
        
        public Dept getDept() {
            return dept;
        }
        
  4. IOC操作bean管理(xml注入集合属性)
    1. 注入数组类型属性

      注入list集合类型属性

      注入Map集合类型属性

      1. 创建类,定义数组、list、map、set类型属性,生成对应set方法

        package com.company.collectiontype;
        
        import java.util.Arrays;
        import java.util.List;
        import java.util.Map;
        import java.util.Set;
        
        public class Stu {
            private String[] courses;
            private List list;
            private Map maps;
            private Set sets;
        
            public void setCourses(String[] courses) {
                this.courses = courses;
            }
        
            public void setList(List list) {
                this.list = list;
            }
        
            public void setMaps(Map maps) {
                this.maps = maps;
            }
        
            public void setSets(Set sets) {
                this.sets = sets;
            }
        
            public void test(){
                System.out.println(Arrays.toString(courses));
                System.out.println(list);
                System.out.println(maps);
                System.out.println(sets);
        
        
            }
        }
        
      2. 在spring配置文件进行配置

        
        
        
        
        
            
        
                
                    
                        java
                        SQL
        
                    
                
        
                
                    
                        张三
                        小三
                    
                
        
                
                    
                        
                        
                    
                
                
                
                    
                        MySQL
                        Redis
                    
                
            
        
        
        

        测试

        package com.company.testdemo;
        
        import com.company.collectiontype.Stu;
        import org.junit.Test;
        import org.springframework.context.ApplicationContext;
        import org.springframework.context.support.ClassPathXmlApplicationContext;
        
        public class TestSpring5Demo1 {
        
            @Test
            public void testCollection(){
                ApplicationContext context=new ClassPathXmlApplicationContext("bean1.xml");
                Stu stu=context.getBean("stu",Stu.class);
                stu.test();
            }
        }
        
    2. 在集合里面设置对象类型值

      
              
                  
                      
                      
                  
              
              
          
      
      
      
          
              
          
          
              
          
      
    3. 把集合注入部门提取出来

      1. 在spring配置文件中引入名称空间:util

        
        
        
  5. IOC操作bean管理(FactoryBean)
    1. Spring有两种类型bean,一种普通bean,另一种工厂bean(FactoryBean)

      1. 普通bean:在配置文件中定义bean类型就是返回类型

      2. 工厂bean:在配置文件定义bean类型可以和返回类型不一样

        1. 创建类,让这个类作为工厂bean,实现接口FactoryBean

          package com.company.factorybean;
          
          import com.company.collectiontype.Course;
          import org.springframework.beans.factory.FactoryBean;
          
          public class MyBean implements FactoryBean{
          
              //定义返回bean
              @Override
              public Course getObject() throws Exception {
                  Course course= new Course();
                  course.setCname("abc");
                  return course;
              }
          
              @Override
              public Class getObjectType() {
                  return null;
              }
          
          }
          
        2. 实现接口里面的方法,在实现的方法中定义返回的bean类型

          
          
          @Test
          public void testCollection3(){
              ApplicationContext context = new ClassPathXmlApplicationContext("bean3.xml");
              Course course=context.getBean("myBean", Course.class);
              System.out.println(course);
          }
          
  6. IOC操作Bean管理(bean作用域)
    1. 在Spring里面,设置创建bean实例是单实例还是多实例

    2. 在spring里面,默认情况下,bean是单实例对象

      @Test
      public void testCollection2(){
          ApplicationContext context = new ClassPathXmlApplicationContext("bean2.xml");
          Book book1 = context.getBean("book",Book.class);
          Book book2 = context.getBean("book",Book.class);
          //book.test();
          System.out.println(book1);
          System.out.println(book2);
      }
      

      输出结果:

      com.company.collectiontype.Book@7d20d0b
      com.company.collectiontype.Book@7d20d0b

    3. 如何设置单实例还是多实例

      1. 在spring配置文件bean标签里面有属性(scope)用于设置单实例还是多实例

      2. scope属性值

        1. 默认值:singleton,表示是单实例对象
        2. prototype,表示的是多实例对象

        代码:

        
            
                
            
        

        输出结果:

        com.company.collectiontype.Book@7d20d0b
        com.company.collectiontype.Book@77f1baf5

      3. singleton和prototype区别:

        1. singleton单实例,prototype多实例

        2. 设置scope值是singleton时,加载spring配置文件时候就会创建单实例对象

          设置scope值是prototype时,不是在加载spring配置文件时创建对象,在调用getbean方法时创建多实例对象。

  7. IOC操作Bean管理(Bean生命周期)
    1. bean生命周期:

      1. 通过构造器创建bean实例(无参构造)

      2. 为bean的属性设置值和对其他bean引用(调用set方法)

      3. 调用bean的初始化方法(需要进行配置)

      4. bean可以使用了(对象获取到了)

      5. 当容器关闭时,调用bean的销毁的方法(需要进行配置销毁的方法)

            @Test
            public void test4(){
        //        ApplicationContext context = new ClassPathXmlApplicationContext("bean4.xml");
        //        Orders orders=context.getBean("orders", Orders.class);
        //        System.out.println("fouth 获取创建bean实例对象");
        //        System.out.println(orders);
        //        //手动让bean实例销毁
        //        ((ClassPathXmlApplicationContext)context).close();
                ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("bean4.xml");
                Orders orders=context.getBean("orders", Orders.class);
                System.out.println("fouth 获取创建bean实例对象");
                System.out.println(orders);
                //手动让bean实例销毁
                context.close();
        
            }
        
        package com.company.bean;
        
        public class Orders {
        
            public Orders() {
                
                System.out.println("first 执行无参数构造创建bean实例");
            }
        
            private String oname;
            public void setOname(String oname) {
                this.oname = oname;
                System.out.println("second 调用set方法设置属性值");
            }
        
            public void initMethod(){
                System.out.println("third 执行初始化的方法");
            }
        
            public void destoryMethod(){
                System.out.println("fifth 执行销毁的方法");
            }
        }
        
        
            
        
        
    2. bean的后置处理器,bean生命周期有七步

      1. 通过构造器创建bean实例(无参构造)

      2. 为bean的属性设置值和对其他bean引用(调用set方法)

      3. 把bean实例传递bean后置处理器的方法 postProcessBeforeInitialization

      4. 调用bean的初始化方法(需要进行配置)

      5. 把bean实例传递bean后置处理器的方法 postProcessAfterInitialization

      6. bean可以使用了(对象获取到了)

      7. 当容器关闭时,调用bean的销毁的方法(需要进行配置销毁的方法)

        package com.company.bean;
        
        public class Orders {
        
            public Orders() {
                
                System.out.println("first 执行无参数构造创建bean实例");
            }
        
            private String oname;
            public void setOname(String oname) {
                this.oname = oname;
                System.out.println("second 调用set方法设置属性值");
            }
        
            public void initMethod(){
                System.out.println("third 执行初始化的方法");
            }
        
            public void destoryMethod(){
                System.out.println("fifth 执行销毁的方法");
            }
        }
        
        package com.company.bean;
        
        import org.springframework.beans.BeansException;
        import org.springframework.beans.factory.config.BeanPostProcessor;
        
        
        public class MyBeanPost implements BeanPostProcessor {
            @Override
            public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
                System.out.println("把bean实例传递bean后置处理器的方法");
                return bean;
            }
        
            @Override
            public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
                System.out.println("把bean实例传递bean后置处理器的方法");
                return bean;
            }
        }
        
        
            
        
        
        
        
        @Test
        public void test5(){
        
            ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("bean4.xml");
            MyBeanPost myBeanPost=context.getBean("myBeanPost", MyBeanPost.class);
            System.out.println("fouth 获取创建bean实例对象");
            System.out.println(myBeanPost);
            //手动让bean实例销毁
            context.close();
        }
        
  8. IOC操作Bean管理(XML自动装配)
    1. 什么是自动装配

      根据指定装配规则(属性名称或者属性类型),spring自动将匹配的属性值进行注入

    2. 演示过程,两者同理,不能有两个相同的类型

      
          
          
          
      
      
      @Test
      public void test6(){
          ApplicationContext context = new ClassPathXmlApplicationContext("bean5.xml");
          Emp emp=context.getBean("emp", Emp.class);
      
          System.out.println(emp);
      
      
      }
      
  9. IOC操作bean管理(外部属性文件)

    1. 直接配置数据库信息

      1. 配置德鲁伊连接池

      2. 引入德鲁伊连接池依赖jar包

        druid-1.2.9.jar

        
            
                
                
                
                
            
        
    2. 外部属性文件配置数据库连接池

      1. 创建外部属性文件,properties格式文件,写数据库信息

        prop.driverClass=com.mysql.jdbc.Driver
        prop.url=jdbc:mysql;//3306/userDb
        prop.name=root
        prop.password=root
        
        
            
                
            
                
                
            
        
AOP JDBC Template 事务管理 ```
  1. 外部属性文件配置数据库连接池

    1. 创建外部属性文件,properties格式文件,写数据库信息

      prop.driverClass=com.mysql.jdbc.Driver
      prop.url=jdbc:mysql;//3306/userDb
      prop.name=root
      prop.password=root
      
      
          
              
          
              
              
          
      
AOP JDBC Template 事务管理 Spring新特性
转载请注明:文章转载自 www.mshxw.com
本文地址:https://www.mshxw.com/it/940649.html
我们一直用心在做
关于我们 文章归档 网站地图 联系我们

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

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