框架

1.springMvc的基本原理和工作流程
在服务器启动时，先通过web.xml构建DispatcherServlet，构建springmvc容器，平且初始化一些组建例如
handlerMapping和handlerAdapter（处理器适配器）。
如果用户发送的请求符合servlet-mapping的映射路径则把请求转发到DispatcherServlet处理，
根据请求（request）从容器中获取handlerMapping实例再把根据Handler找到对应的HandlerAdapter
平且通过找到的处理器适配器执行handler后返回ModelAndView
在将ModelAndView交由视图解析器等到view返回到页面。
2.springmvc和springboot的区别
springmvc是基于servlet的一个mvc框架，需要自己去配置
springboot视为了简化项目搭建，“约定优于配置”，减少需要配置的东西，并且提供整合包

3.spring的基本原理
Spring的核心机制：依赖注入。
不管是依赖注入(Dependency Injection)还是控制反转(Inversion of Conctrol)，其含义完全相同：
当某个java实例(调用者)需要调用另一个java实例(被调用者)时，传统情况下，通过调用者来创建被调用者的实例，通常通过new来创建，
而在依赖注入的模式下创建被调用者的工作不再由调用者来完成，因此称之为"控制反转"；创建被调用者实例的工作通常由Spring来完成，
然后注入调用者，所以也称之为"依赖注入"。
Bean的生命周期：
①singleton与prototype的区别：
singleton：Spring可以精确的知道该Bean何时被创建、初始化、销毁。对于singleton作用域的Bean，每次客户端请求Spring容器总会返回一个共享的实例。
prototype：Spring容器仅仅负责创建Bean，当容器创建了Bean的实例后，Bean实例完全交给客户端代码管理，容器不在跟踪其生命周期。
每次客户端请求prototype作用域的Bean，都会为他创建一个新的实例，
②AOP的基本概念：
AOP框架不与特定的代码耦合.下面是一些面向切面编程的术语：
切面(Aspect)：业务流程运行到某个特定的步骤，也就是一个应用运行的关注点，关注点可能横切多个对象，所以常常也被称为横切关注点。
连接点(Joinpoint)：程序执行过程明确的点，如方法的调用、异常的抛出，Spring AOP中连接点总是方法的调用。
增强处理(Advice)：AOP框架在特定的切入点执行的增强处理，处理有around、before和After等类型。
切入点(Pointcut)：可以插入增强处理的连接点，简而言之，当某个连接点满足指定要求时，该连接点将被添加增强处理，该连接点也就变
4.springboot的基本原理
主要是由@SpringBootApplication注解下的三个注解起决定性作用
@SpringBootConfiguration、@EnableConfiguration、@ComponentScan
（1）@SpringBootConfiguration使用说明该类是一个配置类 和 xml配置文件一个概念
（2）@ComponentScan使用会去自动扫描指定包下的Bean，springboot默认扫描与启动类同一级的目录包下的类
（3）@EnableConfiguration

//主要依赖与@AutoConfigurationPackage与@Import注解实现自动配置功能
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
**@AutoConfigurationPackage**
**@Import({AutoConfigurationImportSelector.class})**
public @interface EnableAutoConfiguration {
    String ENABLED_OVERRIDE_PROPERTY = "spring.boot.enableautoconfiguration";
    Class<?>[] exclude() default {};
    String[] excludeName() default {};
}

//以mybatis的spring.factories为例
//是以键值对的形式存放自动配置类的类路径
# Auto Configure
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
org.mybatis.spring.boot.autoconfigure.MybatisAutoConfiguration

//然后在通过AutoConfigurationImportSelector类中的getCandidateConfigurations方法找到jar包中的META-INF/spring.factories文件
protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {
        List<String> configurations = **SpringFactoriesLoader.loadFactoryNames**(this.getSpringFactoriesLoaderFactoryClass(), this.getBeanClassLoader());
        Assert.notEmpty(configurations, "No auto configuration classes found in META-INF/spring.factories. If you are using a custom packaging, make sure that file is correct.");
        return configurations;
    }

//org.mybatis.spring.boot.autoconfigure.MybatisAutoConfiguration的部分内容
@Configuration
//判断当前项目是否有该类
@ConditionalOnClass({SqlSessionFactory.class, SqlSessionFactoryBean.class}) 
@ConditionalOnBean({DataSource.class})
//加载配置类文件
@EnableConfigurationProperties({MybatisProperties.class})
@AutoConfigureAfter({DataSourceAutoConfiguration.class})
public class MybatisAutoConfiguration {
    private static final Logger logger = LoggerFactory.getLogger(MybatisAutoConfiguration.class);
    private final MybatisProperties properties;
    private final Interceptor[] interceptors;
    private final ResourceLoader resourceLoader;
    private final DatabaseIdProvider databaseIdProvider;
    private final List<ConfigurationCustomizer> configurationCustomizers;

    public MybatisAutoConfiguration(MybatisProperties properties, ObjectProvider<Interceptor[]> interceptorsProvider, ResourceLoader resourceLoader, ObjectProvider<DatabaseIdProvider> databaseIdProvider, ObjectProvider<List<ConfigurationCustomizer>> configurationCustomizersProvider) {
        this.properties = properties;
        this.interceptors = (Interceptor[])interceptorsProvider.getIfAvailable();
        this.resourceLoader = resourceLoader;
        this.databaseIdProvider = (DatabaseIdProvider)databaseIdProvider.getIfAvailable();
        this.configurationCustomizers = (List)configurationCustomizersProvider.getIfAvailable();
    }

    @PostConstruct
    public void checkConfigFileExists() {
        if (this.properties.isCheckConfigLocation() && StringUtils.hasText(this.properties.getConfigLocation())) {
            Resource resource = this.resourceLoader.getResource(this.properties.getConfigLocation());
            Assert.state(resource.exists(), "Cannot find config location: " + resource + " (please add config file or check your Mybatis configuration)");
        }

    }

    @Bean
    @ConditionalOnMissingBean
    public SqlSessionFactory sqlSessionFactory(DataSource dataSource) throws Exception {
        SqlSessionFactoryBean factory = new SqlSessionFactoryBean();
        factory.setDataSource(dataSource);
        factory.setVfs(SpringBootVFS.class);
        if (StringUtils.hasText(this.properties.getConfigLocation())) {
            factory.setConfigLocation(this.resourceLoader.getResource(this.properties.getConfigLocation()));
        }

        org.apache.ibatis.session.Configuration configuration = this.properties.getConfiguration();
        if (configuration == null && !StringUtils.hasText(this.properties.getConfigLocation())) {
            configuration = new org.apache.ibatis.session.Configuration();
        }

        if (configuration != null && !CollectionUtils.isEmpty(this.configurationCustomizers)) {
            Iterator var4 = this.configurationCustomizers.iterator();

            while(var4.hasNext()) {
                ConfigurationCustomizer customizer = (ConfigurationCustomizer)var4.next();
                customizer.customize(configuration);
            }
        }

        factory.setConfiguration(configuration);
        if (this.properties.getConfigurationProperties() != null) {
            factory.setConfigurationProperties(this.properties.getConfigurationProperties());
        }

        if (!ObjectUtils.isEmpty(this.interceptors)) {
            factory.setPlugins(this.interceptors);
        }

        if (this.databaseIdProvider != null) {
            factory.setDatabaseIdProvider(this.databaseIdProvider);
        }

        if (StringUtils.hasLength(this.properties.getTypeAliasesPackage())) {
            factory.setTypeAliasesPackage(this.properties.getTypeAliasesPackage());
        }

        if (StringUtils.hasLength(this.properties.getTypeHandlersPackage())) {
            factory.setTypeHandlersPackage(this.properties.getTypeHandlersPackage());
        }

        if (!ObjectUtils.isEmpty(this.properties.resolveMapperLocations())) {
            factory.setMapperLocations(this.properties.resolveMapperLocations());
        }

        return factory.getObject();
    }
    }

4.mybatis基本总结
（1）是一个半ORM（对象关系映射）的框架，因为他在处理关联关系的时候需要自己写sql语句，而Hibernate则通过一对多，一对一，多对多注解进行解释关系。
（2）#{}与${}的区别
#｛｝是代表预编译语句中的？占位符，预编译就是数据库驱动先把sql和参数发送到DBMS，进行sql的预编译处理。然后就可以直接执行sql。
$｛｝是代表sql语句字符串拼接，容易出现sql注入问题。