Spring01

1、spring

　　源码地址：https://repo.spring.io/libs-release-local/org/springframework/

---

2、配置

　　

---

　　Person类

package com.mashibing.spring;

public class Person {
    private String name;
    private int age;
    private Food food;
    
    
    public Person(String name, int age, Food food) {
        super();
        this.name = name;
        this.age = age;
        this.food = food;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public Food getFood() {
        return food;
    }
    public void setFood(Food food) {
        this.food = food;
    }
    
    
}

　　Food类

package com.mashibing.spring;

public class Food {
    
    private String name;
    
    public Food(String name) {
        super();
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Food [name=" + name + "]";
    }
    
    
}

　　applicationContext.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-3.0.xsd">
   <bean id = "person" class = "com.mashibing.spring.Person">
        <constructor-arg name="name" value="maxiaosan"></constructor-arg>
        <constructor-arg name="age" value="18"></constructor-arg>
        <constructor-arg name="food" ref="food"></constructor-arg>
   </bean>
   <bean id="food" class="com.mashibing.spring.Food">
        <constructor-arg name="name" value="香蕉"></constructor-arg>
   </bean>
</beans>

　　TestGetBean类

package com.mashibing.spring;


import org.apache.commons.lang3.builder.ToStringBuilder;
import org.apache.commons.lang3.builder.ToStringStyle;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestGetBean {
    public static void main(String[] args) {
        ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
        Person person = ctx.getBean("person",Person.class);
        //Food food = ctx.getBean("food",Food.class);
//        food.setName("香蕉");
//        person.setName("zhangsan");
//        person.setAge(18);
//        person.setFood(food);
        //和复写实体类中得toString方法一样，需要依赖common-lang包 /01SpringHelloWorld/libs/commons-lang3-3.9.jar
        System.out.println(ToStringBuilder.reflectionToString(person, ToStringStyle.MULTI_LINE_STYLE));
    }
}

---

3、基于XML的DI

解析applicationContext.xml

并不是所有都会在联网情况下找xsd文件。

<?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-3.0.xsd">
</beans>

2 <beans xmlns = "http://www.springframework.org/schema/beans"    ns-namespace  只是表示一个id和类名上的包名一样

　　PluggableSchemaResolver这个类会去加载.xsd文件

　　

PluggableSchemaResolver源码：

/*
 * Copyright 2002-2019 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      https://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.springframework.beans.factory.xml;

import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.Map;
import java.util.Properties;
import java.util.concurrent.ConcurrentHashMap;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.xml.sax.EntityResolver;
import org.xml.sax.InputSource;

import org.springframework.core.io.ClassPathResource;
import org.springframework.core.io.Resource;
import org.springframework.core.io.support.PropertiesLoaderUtils;
import org.springframework.lang.Nullable;
import org.springframework.util.Assert;
import org.springframework.util.CollectionUtils;

/**
 * {@link EntityResolver} implementation that attempts to resolve schema URLs into
 * local {@link ClassPathResource classpath resources} using a set of mappings files.
 *
 * <p>By default, this class will look for mapping files in the classpath using the
 * pattern: {@code META-INF/spring.schemas} allowing for multiple files to exist on
 * the classpath at any one time.
 *
 * <p>The format of {@code META-INF/spring.schemas} is a properties file where each line
 * should be of the form {@code systemId=schema-location} where {@code schema-location}
 * should also be a schema file in the classpath. Since {@code systemId} is commonly a
 * URL, one must be careful to escape any ':' characters which are treated as delimiters
 * in properties files.
 *
 * <p>The pattern for the mapping files can be overridden using the
 * {@link #PluggableSchemaResolver(ClassLoader, String)} constructor.
 *
 * @author Rob Harrop
 * @author Juergen Hoeller
 * @since 2.0
 */
public class PluggableSchemaResolver implements EntityResolver {

    /**
     * The location of the file that defines schema mappings.
     * Can be present in multiple JAR files.
     */
    public static final String DEFAULT_SCHEMA_MAPPINGS_LOCATION = "META-INF/spring.schemas";


    private static final Log logger = LogFactory.getLog(PluggableSchemaResolver.class);

    @Nullable
    private final ClassLoader classLoader;

    private final String schemaMappingsLocation;

    /** Stores the mapping of schema URL -> local schema path. */
    @Nullable
    private volatile Map<String, String> schemaMappings;


    /**
     * Loads the schema URL -> schema file location mappings using the default
     * mapping file pattern "META-INF/spring.schemas".
     * @param classLoader the ClassLoader to use for loading
     * (can be {@code null}) to use the default ClassLoader)
     * @see PropertiesLoaderUtils#loadAllProperties(String, ClassLoader)
     */
    public PluggableSchemaResolver(@Nullable ClassLoader classLoader) {
        this.classLoader = classLoader;
        this.schemaMappingsLocation = DEFAULT_SCHEMA_MAPPINGS_LOCATION;
    }

    /**
     * Loads the schema URL -> schema file location mappings using the given
     * mapping file pattern.
     * @param classLoader the ClassLoader to use for loading
     * (can be {@code null}) to use the default ClassLoader)
     * @param schemaMappingsLocation the location of the file that defines schema mappings
     * (must not be empty)
     * @see PropertiesLoaderUtils#loadAllProperties(String, ClassLoader)
     */
    public PluggableSchemaResolver(@Nullable ClassLoader classLoader, String schemaMappingsLocation) {
        Assert.hasText(schemaMappingsLocation, "'schemaMappingsLocation' must not be empty");
        this.classLoader = classLoader;
        this.schemaMappingsLocation = schemaMappingsLocation;
    }


    @Override
    @Nullable
    public InputSource resolveEntity(@Nullable String publicId, @Nullable String systemId) throws IOException {
        if (logger.isTraceEnabled()) {
            logger.trace("Trying to resolve XML entity with public id [" + publicId +
                    "] and system id [" + systemId + "]");
        }

        if (systemId != null) {
            String resourceLocation = getSchemaMappings().get(systemId);
            if (resourceLocation == null && systemId.startsWith("https:")) {
                // Retrieve canonical http schema mapping even for https declaration
                resourceLocation = getSchemaMappings().get("http:" + systemId.substring(6));
            }
            if (resourceLocation != null) {
                Resource resource = new ClassPathResource(resourceLocation, this.classLoader);
                try {
                    InputSource source = new InputSource(resource.getInputStream());
                    source.setPublicId(publicId);
                    source.setSystemId(systemId);
                    if (logger.isTraceEnabled()) {
                        logger.trace("Found XML schema [" + systemId + "] in classpath: " + resourceLocation);
                    }
                    return source;
                }
                catch (FileNotFoundException ex) {
                    if (logger.isDebugEnabled()) {
                        logger.debug("Could not find XML schema [" + systemId + "]: " + resource, ex);
                    }
                }
            }
        }

        // Fall back to the parser's default behavior.
        return null;
    }

    /**
     * Load the specified schema mappings lazily.
     */
    private Map<String, String> getSchemaMappings() {
        Map<String, String> schemaMappings = this.schemaMappings;
        if (schemaMappings == null) {
            synchronized (this) {
                schemaMappings = this.schemaMappings;
                if (schemaMappings == null) {
                    if (logger.isTraceEnabled()) {
                        logger.trace("Loading schema mappings from [" + this.schemaMappingsLocation + "]");
                    }
                    try {
                        Properties mappings =
                                PropertiesLoaderUtils.loadAllProperties(this.schemaMappingsLocation, this.classLoader);
                        if (logger.isTraceEnabled()) {
                            logger.trace("Loaded schema mappings: " + mappings);
                        }
                        schemaMappings = new ConcurrentHashMap<>(mappings.size());
                        CollectionUtils.mergePropertiesIntoMap(mappings, schemaMappings);
                        this.schemaMappings = schemaMappings;
                    }
                    catch (IOException ex) {
                        throw new IllegalStateException(
                                "Unable to load schema mappings from location [" + this.schemaMappingsLocation + "]", ex);
                    }
                }
            }
        }
        return schemaMappings;
    }


    @Override
    public String toString() {
        return "EntityResolver using schema mappings " + getSchemaMappings();
    }

}

引入多个配置文件：

　　

---

　　id和name都可以标记bean

　　      

---

　　

---

　　

---

4、不用构造器的属性注入

　　

 　　

　　

　　启动程序报上面错误，说明Person对象必须有无参构造器。

　　加一段：xmlns:p=http://www.springframework.org/schema/p

　　<bean id="person" class="com.msb.Person" p:age="21" p:name="zhangsan" p:food-ref = "food">

 5、Properties

　　Person类

package com.mashibing.spring;

import java.util.Properties;

public class Person {
    
    public Person() {
        super();
    }
    private String name;
    private int age;
    private Food food;
    
    private Properties gift;
    
    
    public Person(String name, int age, Food food) {
        super();
        this.name = name;
        this.age = age;
        this.food = food;
    }
    
    
    public Properties getGift() {
        return gift;
    }


    public void setGift(Properties gift) {
        this.gift = gift;
    }


    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public Food getFood() {
        return food;
    }
    public void setFood(Food food) {
        this.food = food;
    }
    
    
}

　　 

---

　　Person类：

　　

 application.xml中

　　

 6、作用域

spring中的get出来的默认都是单例的。

spring为bean提供了6个作用域：singleton、prototype、websocket、request、session、application都是单例的

prototype：

　　

 　　

---

 7、关于Spring

为什么用单例？

性能问题。

单例在并发场景下有没有问题？

有。在单例类里面不能有状态数据，如果有要非常小心

线程的连接和关闭都放到ThreadLocal里面进行隔离。

8、延迟加载

lazy-init="true"懒加载

9、工厂类

Car接口：

package com.mashibing.spring;

public interface Car {
    
    public String getName();
    
    public String getPrice();
}

Audi实现类:

package com.mashibing.spring;

public class Audi implements Car {

    @Override
    public String getName() {
        return "我是奥迪A7";
    }

    @Override
    public String getPrice() {
        return "700000";
    }

}

Bmw实现类：

package com.mashibing.spring;

public class Bmw implements Car {

    @Override
    public String getName() {
        return "BMW 7";
    }

    @Override
    public String getPrice() {
        return "700000";
    }

}

工厂CarFactory类：

package com.mashibing.spring;

/**
 * 简单工厂
 * @author 14308
 *
 */
public class CarFactory {
    
    public Car getCar(String name) throws Exception{
        if (name.equals("audi")) {
            return new Audi();
        } else {
            throw new Exception("暂时没法生产这辆车");
        }
    }
}

Test类：

 疑问？？？如果是web项目那么每次要修改参数都要在程序中修改一次。

下面用bean工厂的方式创建

　　动态工厂创建：

<?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-3.0.xsd">
     
    <bean id="carFactory" class="com.mashibing.spring.CarFactory"/>
        
    <bean id="car" factory-bean="carFactory" factory-method="getCar">
        
          <constructor-arg value="audi"></constructor-arg>
    </bean>
</beans>

　　

---