[自主学习一:Spring]day01_MySpring_CoreSpring

Posted 2020-08-21

 

1、根据jar包需要，导入spring核心jar包。

 

 

2、编写spring的context上下文环境

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!-- bean definitions here -->

</beans>

 

3、编写java类

3.1、编写POJO类

package com.corespring.core;

public class UserInfo {
    private String userName;
    private String userPass;
    private String empno;
    
    public UserInfo(){
        System.out.println("调用空参构造函数");
    }
    
    public UserInfo(String userName) {
        super();
        this.userName = userName;
    }
    
    public UserInfo(String userName, String userPass) {
        super();
        this.userName = userName;
        this.userPass = userPass;
        System.out.println("调用-2-个参数的构造函数");
    }
    
    public UserInfo(String userName, String userPass, String empno) {
        super();
        this.userName = userName;
        this.userPass = userPass;
        this.empno = empno;
        System.out.println("调用--3--个参数的构造函数");
    }
    
    public String getUserName() {
        return userName;
    }
    public void setUserName(String userName) {
        this.userName = userName;
    }
    public String getUserPass() {
        return userPass;
    }
    public void setUserPass(String userPass) {
        this.userPass = userPass;
    }
    
    public String getEmpno() {
        return empno;
    }

    public void setEmpno(String empno) {
        this.empno = empno;
    }
}

3.2、编写service层:

接口:

package com.corespring.core.biz;

import java.util.List;

import com.corespring.core.UserInfo;

public interface IUserBiz {
    public abstract List<UserInfo> findList();//接口里面的方法都是抽象方法，但修饰符public abstract是默认的，所以也可以省略不写
}

该接口的实现类:

package com.corespring.core.biz.impl;

import java.util.List;

import com.corespring.core.UserInfo;
import com.corespring.core.biz.IUserBiz;
import com.corespring.core.dao.IUserDao;

public class UserBizImpl implements IUserBiz{
    public UserBizImpl(){
        System.out.println("调用UserBizImpl---空参--构造函数..........");
    }
    
    private IUserDao userDao;
    public UserBizImpl(IUserDao userDao) {
        super();
        this.userDao = userDao;
        System.out.println("调用UserBizImpl--一个参数--构造函数");
    }

    @Override
    public List<UserInfo> findList() {
        return userDao.findAll();
    }
     
}

3.3、编写dao层:

接口:

package com.corespring.core.dao;

import java.util.List;

import com.corespring.core.UserInfo;

public interface IUserDao {
     public abstract List<UserInfo> findAll();//接口方法前面的修饰符默认为：public abstract，所以不写这两个单词也行
}

该接口的实现类:

package com.corespring.core.dao.impl;

import java.util.ArrayList;
import java.util.List;

import com.corespring.core.UserInfo;
import com.corespring.core.dao.IUserDao;

public class UserDaoImpl implements IUserDao{

    public UserDaoImpl(){
        System.out.println("UserDaoImpl构造函数");
    }
    
    @Override
    public List<UserInfo> findAll() {
        List<UserInfo> list=new ArrayList<UserInfo>();
        UserInfo  userInfo=null;
        for(int i=0;i<10;i++)
        {
            userInfo=new UserInfo("user"+i,"pass"+i);
            list.add(userInfo);
        }
        return list;
    }
  
}

 

4、配置spring上下文环境:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!-- bean definitions here -->

<!--biz层（服务层）  -->
<bean id="UserBizImpl" class="com.corespring.core.biz.impl.UserBizImpl">
 <!--进行依赖注入时，可以使用value或ref进行注入；ref配置的是其他bean的id值 (即其他由spring管理的类)，可以理解为一个引用，就是引用其他bean的id -->
 <!--当使用ref进行依赖注入时，会先实例化引用对象后，才实例化本类  -->
 <!--因为我们在biz层添加了一个构造函数，用于传递dao层的接口对象，所以，我们要在这里使用构造函数依赖注入的方式，将dao层接口对象传过去  -->
  <constructor-arg name="userDao" ref="UserDaoImpl"></constructor-arg>
</bean>
<!--dao层  -->
<bean id="UserDaoImpl" class="com.corespring.core.dao.impl.UserDaoImpl">
</bean>

<!--配置一个 bean  用于初始化javabean的值，初始化的过程，称为依赖注入(采用的是，使用构造函数初始化值)，如果没有进行值注入，则没有进行初始化，注入值的方法一：<constructor-arg value="nihao"></constructor-arg>    -->
<!--id值 可以任意命名，但不能重名；这个   class 是  想要初始化那个类的引用-->
<bean id="UserInfo" class="com.corespring.core.UserInfo">
    <!--constructor-arg value="abc" 为构造函数初始化默认值 ，它的属性  name 表示指定为某个属性初始化值 -->
    <!--使用构造函数进行依注入：
      1、能够跟根据构造参数的个数自动匹配类的构造函数。
      2、可以不指定参数的名称，此时，会根据类的参数列表顺序进行注入
      3、可以全部或部分指定参数名称(使用name属性)，此时会跟根据参数名称进行注入
      4、如果使用了参数名称 ( name属性)，则参数的配置顺序可以任意颠倒,也就是说，如果没有指定参数名称，则这里的配置顺序，将会对应构造函数那边的书写顺序
      5、配置的参数个数一定要与构造函数匹配
      6、如果在这里配置了初始值，而该初始值没有相应的构造函数，那么是不能实例化成功的，运行时，会出错
      7、这个  bean 可以多次配置，只要id不重复，就可以了
    -->
    <constructor-arg name="empno" value="abc"></constructor-arg> 
    <constructor-arg  value="123456"></constructor-arg> 
    <constructor-arg value="nihao"></constructor-arg>    
</bean>


<!--依赖注入方法二 ,因为这个并没有构造函数的值，所以在实例化这个类的时候，它会调用空参的构造函数，(一个类，实例化的时候，构造函数一定会被执行) -->
<bean id="UserInfo1" class="com.corespring.core.UserInfo">
<!--在使用spring管理对象时，还可以使用set方法进行依赖注入  -->
<!--使用property配置依赖关系时，name属性是必须要配置的  -->
<property name="UserName" value="敏"></property>
<!--在配置property的name时，配置的是set方法后面的名称，而不是类的属性名称  -->
<property name="empno" value="1001"></property>
</bean>
</beans>

 

5、编写测试类

package test;

import java.util.List;

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

import com.corespring.core.UserInfo;
import com.corespring.core.biz.impl.UserBizImpl;

public class TestUserBiz {
     
    public static void main(String[] args) {
        //1.初始化spring上下文环境
        String config="applicationcontext.xml";
        ApplicationContext ctx=new ClassPathXmlApplicationContext(config);
        //2、通过spring上下文环境，调用spring的bean factory实例化对象
        /*其实这里可以直接转成父接口，如：IUserBiz userBiz = (IUserBiz) ctx.getBean("UserBizImpl");
             它能直接转成父接口，这就是接口隔离原则(接口的调用类不关心接口的实现类而只关心接口方法)
        */
        UserBizImpl userBizimpl=(UserBizImpl) ctx.getBean("UserBizImpl");
        System.out.println("调用findlist方法前..........");
        //3.调用实例对象，实现业务功能
        List<UserInfo> list=userBizimpl.findList();
        for (UserInfo userInfo : list) {
            System.out.println(userInfo.getUserName()+"----"+userInfo.getUserPass());
        }
    }
}

注意看看下面这个类:

package test;

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

import com.corespring.core.UserInfo;

public class TestUserInfo {
    //ApplicationContext  ctx;      /*如果测试方法 testSpring2() 时，把这个环境定义为全局*/
    //传统的方法
    private static void test(){
        UserInfo userInfo=new UserInfo();
        System.out.println(userInfo.getUserPass());
    }
    
    
    public static void main(String[] args) {
         // test();
        testSpring();
//        testSpring2();//如果把这个方法放到方法testSpring(); 的前面 ，是不行的，运行出错，因为没有初始化上下文环境
    }
   
    //使用Spring方法
    private static void testSpring(){
        UserInfo userInfo=null;
        
        System.out.println("-----1-----");//打印这些数字，只是为了查看spring的生命周期
        
        //1。初始化spring上下文环境；因为它要预先取读取有多少个需要实例化的变量。在初始化上下文环境的时候，
        //applicationcontext.xml 里面的内容都会被执行
          String config="applicationcontext.xml";
          ApplicationContext  ctx=new ClassPathXmlApplicationContext(config);
          
          System.out.println("------2------");
          
        //2.通过spring上下文环境，调用spring的bean factory 实例化对象
          userInfo=(UserInfo)ctx.getBean("UserInfo1");//UserInfo 这个是applicationcontext.xml bean 的id.
        //3.调用实例化后的对象，实现业务功能
          System.out.println("-----3----");
          System.out.println(userInfo.getUserName());
          System.out.println(userInfo.getUserPass());
          System.out.println(userInfo.getEmpno());
          
    }
    
//    private static void testSpring2(){
//        UserInfo userInfo=null;  
//          userInfo=(UserInfo)ctx.getBean("UserInfo1");//UserInfo 这个是applicationcontext.xml bean 的id.
//          System.out.println("-----3----");
//          System.out.println(userInfo.getUserName());
//          System.out.println(userInfo.getUserPass());
//          System.out.println(userInfo.getEmpno());
//          
//    }
    
    
}

 

好了，到此简单的spring学习完毕，下面附上开发步骤:

Spring开发步骤:

1、新建Java项目
2、把spring的lib库的核心jar包加入到项目的libs中：
  spring-beans-4.1.7.RELEASE.jar  
  spring-context-4.1.7.RELEASE.jar
  spring-core-4.1.7.RELEASE.jar
  spring-expression-4.1.7.RELEASE.jar
 
     而且还要添加日志文件：commons-logging-1.1.3.jar；
     这个日志文件在：文件夹ssh\\spring-framework-4.0.0-dependencies\\files-2.1\\commons-logging\\commons-logging\\1.1.3\\f6f66e966c70a83ffbdb6f17a0919eaf7c8aca7f
  

3、添加spring的context上下文环境
       即是写： applicationcontext.xml文件；这个文件的内容在第七章，标题为:34.2 XML Schema-based configuration 
       
  <?xml version="1.0" encoding="UTF-8"?>
  <beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!-- bean definitions here -->

  </beans>
       
       
4、编写java类，并交给spring进行管理
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!-- bean definitions here -->
<bean id="UserInfo" class="com.corespring.core.UserInfo">
</beans>

5、编写测试类，通过spring bean factory 进行实例化
   private static void testSpring(){
        UserInfo userInfo=null;
        //1。初始化spring上下文环境；因为它要预先取读取有多少个需要实例化的变量
          String config="applicationcontext.xml";
          ApplicationContext  ctx=new ClassPathXmlApplicationContext(config);
          
        //2.通过spring上下文环境，调用spring的bean factory 实例化对象
          userInfo=(UserInfo)ctx.getBean("UserInfo");//UserInfo 这个是applicationcontext.xml bean 的id.
        //3.调用实例化后的对象，实现业务功能
          System.out.println(userInfo.getUserPass());
   }


------------------------------
理解spring的生命周期：
1、spring的使用过程有3个步骤
   (1)。初始化spring上下文环境
   (2)。通过spring上下文环境，调用spring的bean factory实例化对象；
   (3).调用实例化后的对象，实现业务功能

2、当初始化spring环境时，会对配置到spring配置文件中的类进行实例化；
3、当通过bean factory取得实例化对象时，其实是返回实例对象的引用
4、当ApplicationContext对象引用失效时，spring的环境同时失效



------------------------------------------------------------------------------------------------------------------
1、配置xml：第三章的 第七章节
  <?xml version="1.0" encoding="UTF-8"?>
  <beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!-- bean definitions here -->

  </beans>
 

Spring开发使用三层架构:

1、采用面向接口编程思想

2、编写各层次代码：三层结构(视图层、业务层、数据访问层)
      这里的项目使用两个接口、两个接口的实现类
      
3、把接口实现类交给spring进行管理
   <!--biz层  -->
   <bean id="UserBizImpl" class="com.corespring.core.biz.impl.UserBizImpl">
   <!--进行依赖注入时，可以使用value或ref进行注入；ref配置的是其他bean的id值 (即其他由spring管理的类)，可以理解为一个引用，就是引用其他bean的id -->
   <!--当使用ref进行依赖注入时，会先实例化引用对象后，才实例化本类  -->
    <!--因为我们在biz层添加了一个构造函数，用于传递dao层的接口对象，所以，我们要在这里使用构造函数依赖注入的方式，将dao层接口对象传过去  -->
   <constructor-arg name="userDao" ref="UserDaoImpl"></constructor-arg>
   </bean>
   <!--dao层  -->
   <bean id="UserDaoImpl" class="com.corespring.core.dao.impl.UserDaoImpl">
   </bean> 
   
4、编写测试类(视图层)，使用spring框架功能
      public static void main(String[] args) {
        //1.初始化spring上下文环境
        String config="applicationcontext.xml";
        ApplicationContext ctx=new ClassPathXmlApplicationContext(config);
        //2、通过spring上下文环境，调用spring的bean factory实例化对象
        /*其实这里可以直接转成父接口，如：IUserBiz userBiz = (IUserBiz) ctx.getBean("UserBizImpl");
             它能直接转成父接口，这就是接口隔离原则(接口的调用类不关心接口的实现类而只关心接口方法)
        */
        UserBizImpl userBizimpl=(UserBizImpl) ctx.getBean("UserBizImpl");
        System.out.println("调用findlist方法前..........");
        //3.调用实例对象，实现业务功能
        List<UserInfo> list=userBizimpl.findList();
        for (UserInfo userInfo : list) {
            System.out.println(userInfo.getUserName()+"----"+userInfo.getUserPass());
        }
    }   

 

附上项目结构图: