Spring MVC学习入门笔记

课前预习

Spring 第一天

学习Spring的容器功能，就是创建管理对象的能力

使用Spring

  1. 添加依赖

  2. 创建XML文件

  3. 配置bean

  4. 实例化上下文类

  5. getBean得到对象

name

分隔符是什么？ 分隔符可以混用吗？ 多个bean的name配置可以有相同的吗？

配置的3种方式

  • 直接class配置，实例化的是class代表的对象

  • 工厂方法

    • factory-method

    • factory-bean factory-method ，factory-bean可以指向自己吗？

  • FactoryBean

作用域

Singleton :由容器管理对象的生命周期，也就是说容器存在，对象就创建出来（设定的init方法会执行，容器销毁，管理的对象也会销毁

    （设定的销毁方法会执行）

Prototype：getBean的临时产生一个，产生之后的对象，spring容器就不管理，由程序自己去管理它的销毁

全局的配置：default-xxxx

调用销毁方法


((ConfigurableApplicationContext)applicationContext).close();

多配置文件

1 import2 new xxx("","")验证：每个文件里面配置一个beangetBean的时候都能得到

 

 

 

 

 

 

 

 

 

 

使用Spring步骤

  1. 添加依赖
  2. 创建xml文件
  3. 配置（需要被管理的类）bean
  4. 实例化上下文类
  5. GetBean对象

 

使用idea新建一个maven项目，在pom.xml中添加依赖：

<dependencies>
        <!-- https://mvnrepository.com/artifact/org.springframework/spring-context -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>4.3.13.RELEASE</version>
        </dependency>
</dependencies>

创建一个实体，Student.java：

package entity;

public class Student {
    public void hello(){
        System.out.println("hello SPring MVC！");
    }
}

选中项目右键--创建一个Spring Config：

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

在实体包下写一个Main.java类用于测试：

package entity;

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

public class Main {
    public static void main(String[] args) {
        //超类ApplicationContext（是一个接口）--所以需要new子类
        //ClassPath类路径==和代码放在一起的，同在main文件夹下面
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("springMVC.xml");
        //Ctrl+H (快捷键)-->可看类型的层次 
        Student student = (Student) applicationContext.getBean("stu");     //xml的id名
        student.hello();
}

项目目录结构：

 

 

 

问题:

　　

 

答：分隔符之间可以混用，分别可以使用，；（空格）三种符号作为分隔符，而：则会报错，测试代码如下：

　　　　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" xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">
    <bean id="stu" name="student s,st" class="entity.Student"></bean>
    <!--可以混用-->

    <!--<bean id="stu" name="student,s" class="entity.Student"></bean>
    <bean id="stu" name="student;s" class="entity.Student"></bean>-->

</beans>

　　　　Main.java测试的代码：

ApplicationContext applicationContext = new ClassPathXmlApplicationContext("springMVC.xml");
        //Ctrl+H -->类型的层次 xsd
        /*Student student = (Student) applicationContext.getBean("stu");
        student.hello();

        Student student1 = (Student) applicationContext.getBean("student");
        student1.hello();

        Student student2 = (Student) applicationContext.getBean("s");
        student2.hello();

        Student student3 = (Student) applicationContext.getBean("st");
        student3.hello();*/

 

　　<!--创建对象有三种形式：1.直接new；2.间接使用工厂类new-为什么用：;3.实现接口-->

第一种：即上边提到的一种

第二种：

　　　　实体代码：

package entity;

public class Student {
  
    public static Student hello(){
        System.out.println("hello SPring MVC！");
        return new Student();
    }

}

　　　　xml代码:

<bean id="xx" class="entity.Student" factory-method="hello"></bean>

　　　　Main测试代码:

Student student4 = (Student) applicationContext.getBean("xx");

 

第三种：

　　　　实体代码:

public Student hello (){
       System.out.println("hello SPring MVC！");
       return new Student();
   }

　　　　xml代码（方法一）:

<bean id="factory" class="entity.Student"></bean>
    <bean id="yy" class="entity.Student" factory-bean="factory" factory-method="hello"></bean>

　　　　xml代码（方法二）：　　

<!--xml中能否写自己:不可以？别名呢？可以-->
<bean id="factory" class="entity.Student" name="student s"></bean>
    <bean id="yy" class="entity.Student" factory-bean="s" factory-method="hello"></bean>

　　　　Main测试代码：

Student student5 = (Student) applicationContext.getBean("yy");

 

　　<!--xml配置中能否去id，怎么写-->

实体代码:
public static Student hello(){
        System.out.println("hello SPring MVC！");
        return new Student();
    }


　xml代码：




<bean class="entity.Student"></bean>




   Main测试代码：




Student student6 =  applicationContext.getBean(Student.class);
student6.hello();




 


作用域


Singleton :由容器管理对象的生命周期，也就是说容器存在，对象就创建出来（设定的init方法会执行，容器销毁，管理的对象也会销毁（默认即为Singleton作用域）




    （设定的销毁方法会执行）


代码示例：


实体代码：




package test02.beans;

public class Emps {
    public Emps() {
        System.out.println("Emps的构造方法");
    }

    public void aa (){
        System.out.println("初始化。。。");
    }

    public void bb (){
        System.out.println("销毁。。。");
    }

}




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 id="emp" class="test02.beans.Emps" scope="singleton" init-method="aa" destroy-method="bb"></bean>

</beans>




Main.java测试代码：




package test02.beans;

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

public class Main {
    public static void main(String[] args) {
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("EmpsMVC.xml");

        ((ConfigurableApplicationContext)applicationContext).close();
    }
}




运行效果图：


 


 


 




Prototype：getBean的临时产生一个，产生之后的对象，spring容器就不管理，由程序自己去管理它的销毁




代码示例：


实体代码：同上


xml代码:




<bean id="emp" class="test02.beans.Emps" scope="prototype" init-method="aa" destroy-method="bb"></bean>




Main测试代码:


1.如果同上代码运行是没有结果的


2.




public class Main {
    public static void main(String[] args) {
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("EmpsMVC.xml");
        Emps emps = (Emps) applicationContext.getBean("emp");

        ((ConfigurableApplicationContext)applicationContext).close();
    }
}




运行结果同上。


 


 


如果有很多的实体都有相同的初始化方法，和销毁方法，那么可以选择在配置文件中定义全局的初始化或者销毁的方法




default-init-method=""

default-destroy-method=""






 




 


多配置文件（两个xml的的关联方法）


1.在Main.java中new两个ApplicationContext，再关联：


验证：每个文件里面配置一个beangetBean的时候都能得到


2.ApplicationContext中指定多个参数“，”相隔"：new xxx("","")


 




ApplicationContext applicationContext = new ClassPathXmlApplicationContext("EmpsMVC.xml","springMVC.xml");




 


3..搞一个总的配置文件，导入左右相关联的，在xml中写如下代码




<import resource="springMVC.xml"></import>






项目目录结构：




 


EmpMVC.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">

    <import resource="springMVC.xml"></import>

    <!--默认为单例作用域-->
    <bean id="emp" class="test02.beans.Emps" scope="singleton" init-method="aa" destroy-method="bb"/>

</beans>




Main测试代码:




package test02.beans;

import entity.Student;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Main {
    public static void main(String[] args) {
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("EmpsMVC.xml");

        Student student = (Student) applicationContext.getBean("stu");

        ((ConfigurableApplicationContext)applicationContext).close();
    }
}




运行结果：




 


 




补充：接口：


InitializingBean


DisposableBean


代码示例:
ClassBean.java实体代码：




package test03;

import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.InitializingBean;

public class ClassBean implements InitializingBean,DisposableBean {

    public void init (){
        System.out.println("init----------");
    }

    public void xiaohui (){
        System.out.println("xiaohui----------");
    }

    public void afterPropertiesSet() throws Exception {
        System.out.println("afterPropertiesSet--------------");
    }
    
    public void destroy() throws Exception {
        System.out.println("destroy----------------");
    }
}




xml代码:




<bean id="clb" class="test03.ClassBean" init-method="init" destroy-method="xiaohui"></bean>




   Main测试代码：




public class Main {
    public static void main(String[] args) {

        /*优先级不同，接口的初始化与销毁会先输出*/
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("classBeanMVC.xml");
        ClassBean classBean = (ClassBean) applicationContext.getBean("clb");
        ((ConfigurableApplicationContext)applicationContext).close();

    }
}




 










            

            
posted @ 
2018-01-15 13:41 
梁宝谊 
阅读(401) 
评论(0) 
编辑 
收藏 
举报