~Spring概念
1.spring是开源的轻量级框架，即要使用spring时只需导入相应的jar包，而不用以来其他东西。
2.spring的核心两个主要部分：
（1）aop：面向对切面编程，扩展功能而不用修改代码！
（2）IOC：控制反转。举个栗子
比如有一个类，在类里面有个方法有一个实现某功能方法（非静态），我们要使用这个方法就必须要new一个对象，
而使用spring，我们就把实例化一个对象交给spring的配置文件来做，通过以来注入方式来注入这个对象。
3.spring是个一站式编程框架，在j2ee的三层结构中都有作用：
（1） web层：springMVC
（2）service层：spring的ioc
（3）dao（即 data access object数据访问对象）层：spring的jdbcTemplate
4.现在使用的版本
hibernate5.x
spring4.x
~Spring的ioc操作
1.就是把对象的实例化交给spring处理
2.ioc操作的两部分：（1）ioc配置文件的方式 （2）ioc的注解方法
~ioc的底层原理
1.底层原理使用技术
（1）xml配置文件
（2）dom4j解决xml
（3）工厂模式（高内聚低耦合思想：在一个类里面要精密相连，类与类之间要很少关联，不然一个改变就得改变很多）
spring在程序中大大实现了解耦合，在spring前，人们可以用工厂模式进行解耦合操作 。
可以看出工厂模式还是让使用的类与工厂类耦合了
（4）反射
2.下面详细介绍下ioc是怎么运用到这四个技术的，用张图介绍：
~IOC入门案例
第一步 导入jar包
多的不说，intellij自动导入，具体看视频-NO.5-（日志类必须，我深深的被坑了！）
第二步 创建类，创建类方法
第三部 创建spring配置文件，配置创建类
（1）spring的配置文件位置是不固定
的建议放在src下面， 名称没有要求，官方建议appliactionContext.xml
（2）引入scheme约束（找约束-NO.6-）
（3）配置对象
第四步 测试创建类
~Spring的bean管理（xml方式）
bean实例化的方式
1.在spring里面配置文件创建对象
2.bean实例化三种方式的实现
（1）使用类的无参构造构造对象（这是重点，javabean类中必须要有无参构造函数，不然报错）
（2）使用静态工厂方式
工厂类中有个静态方法返回类对象
创建一个静态工厂类
配置bean
factory-method=“”即表示的是工厂类中返回对象的方法名
然后同样的方式就可获得bean对象
（3）使用实例工厂创建
返回对象的方法不是静态的
配置成这样，获取的java代码一样！
这个更麻烦了知道就可以！
~上面介绍了三种获取javabean的方法，下面讲讲bean标签创建的属性
bean标签常用属性
（1）id属性，即取名字，代码根据id值获取创建的对象
（2）name属性，和id属性值作用一样 id属性值不能包含特殊符号，但这个可以，现在不用了！
（3）class属性，创建对象所在类的全路径
（4）scope属性，表示bean的作用范围，这个有多个属性值
主要用和掌握前两个，不谢的话默认是单例对象（第一个） (具体了解-NO.10-)
~属性注入
1.创建对象时，想其属性注入相应的值
2.属性注入三种方式（前两种较常用）
（1）setter方法注入 （2）有参数的构造注入 （3）使用接口注入
java代码中的属性注入
spring属性值注入只支持前两种
用的最多的是setter注入
3.注入对象属性（重点）
在日常的编程过程中，不可能是光是使用spring的功能去注入string等简单类型属性，多的还是注入对象属性类型，在j2ee代码中，多是通过service来控制dao的使用，即service中通常会有一个或多个Dao属性对象。
在xml配置文件中配置差不多是这样的：
4.p名称空间注入
看视频吧（-NO.15-）
5.注入复杂类型属性
（1）数组
（2）list集合（和数组很类似啊）
（3）map集合
（4）properities类型
~IOC和DI的区别
1.IOC：控制反转，把对象交给spring进行配置
2.DI：依赖注入，向类里面的属性设置值
3.关系：依赖注入不能单独存在，需要在ioc的基础上完成操作
~spring整合web项目原理（好像很重要 -NO.17-）
1.实现思想
要使用spring时，进行操作时鼻血要new一个ApplicationContext对象来加载配置文件，然后才可以根据这个配置文件来进行对象的创建
然而这个操作效率非常的低，程序性能就会很低。所以就可以将这个对象的new过程放在服务器开启的时候完成，和session的加载差不多！
2.实现原理
（1）将对象放入ServletContext
（2）监听器原理
（3）具体使用
●现在服务器启动的时候，为每个项目创建一个ServletContext对象
●在Servlet创建的时候，使用监听器可以具体到ServletContext对象什么时候创建
●在监听到ServletContext创建的时候加载spring配置文件，把配置文件配置对象创建出来
●把穿件出来的对象放到ServletContext域中（setAttribute方法！）
●取的时候，到ServletContext域中取（getAttribute方法！）
（4）具体配置过程放后面讲，先说些别的
~Spring的bean管理（注解）
1.注解
.代码里面特殊的标记，使用注解可以完成部分功能
.注解的写法@注解名称（属性名=属性值）
.注解使用可以放在类、方法、属性上面
2.spring的注解开发准备
（1）导入jar包
●导入最基本jar包
●以及spring-aop包（注解用）
（2）创建类创建方法
●略
（3）创建spring配置文件，引入约束
●具体过程可以看视频（-NO.19-），intellij好像会自动配置
●引入约束后不需要再写<bean>了，只需开启注解扫描，添加
<context:componet_scan back-package=""><context:componet_scan> 然后会扫描back-package属性所指定的包，根据扫描到的注解实现相应的功能操作
<context:annotation-config></context:annotation-config>如果只添加这句的话就只扫描属性上面的注解，所以还是用上上面那条比较方便！
（4）用注解方式创建对象
●在创建对象的类上面使用注解实现
●创建对象还有另外三个注解
○@Controller ：web层
○@Service : 业务层
○@Repositiry ： 持久层
它们功能都是一样的，比较推荐的就是各层的类用各层相应的注解
最好记住两个 Service Conponent
●创建对象时标明是单实例还是多实例的方式
只需在类上面添加一条@Scope（value="prototype"）或者单例singleton
（5）然后就像有配置bean时使用方法一样了。
~注解方式注入属性
1.创建service类，再创建一个Dao类，然后在service类里面得到Dao的对象
@Autowired(value=“”)表示的是自动装配，bean中用的是value
用autowired时好像Dao类中的@Conponent没有用，因为后台是通过属性类型找到相应的类名然后创建的，和 @Component中的value没有关系，乱写都可以
这个也行，就相当于前面说的用name标识bean时用的name属性，这时候就关上面说的value的事了。
~配置文件和注解方式的混合使用
（以为单纯使用注解方式才是最完美的，但注解的太分散，这样可读性很差，混合使用就能结合两个的优点）
使用诸如配置文件中配置对象，用注解方式注入属性。
~~AOP概念
1.Aspect Oriented Programing面向切面编程，扩展一个方法的功能不用修改代码的实现。
2.AOP采取横向抽取机制，取代了传统的纵向集成体系重复性代码
~~AOP原理
画图分析原理：
横向抽取机制 有接口
没有接口
~~AOP操作术语
比如将一个类中的add方法扩展个写日志功能，将log（）放在add后，那么这个add就是切入点，log就是切面， 放在add后就是通知！
~~Spring的aop操作（配置实现）
//学期结束，时间也变得充裕，现在要跟着打代码了！
1.首先我们先创建两个类，一个增强类，一个切入点类
package cn.calculater;
public class Logger {
public void beforeAdd() {
System.out.println("这是Calculater类中的add方法的前置增强方法！");
}
}
package cn.calculater;
public class Calculater {
public void add() {
System.out.println("这是add方法！");
}
}2.在配置文件中完成类对象的配置
<!--1.配置aop使用的对象-->
<bean id="calculater" class="cn.calculater.Calculater"/>
<bean id="logger" class="cn.calculater.Logger"/>3.在配置文件中配置切面
<!--2.配置aop操作-->
<aop:config>
<!--2.1配置aop切入点-->
<aop:pointcut id="pointcut1" expression="execution(* cn.calculater.Calculater.add(..))"/>
<!--2.2配置切面
把增强放在方法上面
-->
<aop:aspect ref="logger">
<!--method=""表示增强类那个方法作为前置-->
<aop:before method="beforeAdd" pointcut-ref="pointcut1"/>
</aop:aspect>
</aop:config>expression使用的是表达式配置切入点，基本格式是：
execution（<访问修饰符> <返回类型><方法名><参数><异常>）
几种写法：
（1）execution(* cn.calculater.calculater.add(..))表示是cn.calculater.calculater类中的所有add方法！
（2）execution(* cn.calculter.calculater.*（..）)表示是cn.calculater.calculater类中的所有方法！
（3）execution(* *.*(..))表示是所有类的所有的方法！
4.最后我们来看看实现的效果！
好吧报错，好像要写aspectj很麻烦诶，看到有些博客都要配置环境变量，后面要用的话在完善吧！这里真没力气了解这个了，都不一定用得上！要看的话就看（--NO.29-NO.30--）
~~log4j的相关介绍
1.通过logj能看到程序运行过程中看到更加详细的信息
（1）经常使用log4j查看日志
2.使用
（1）导入log4j的jar包
（2）复制log4j的配置文件到src包里面
（3）找到log4j.properties，然后就把它放在src目录下面！ 就行
据图看（--NO.31--）
~~Spring整合web项目
1.演示之前方法出现的问题：
（1）jsp 调用service， service调用数据库操作类dao。
在jsp中调用service和在service中调用dao类都使用spring属性注入方式！
创建dao类：
package cn.dao;
public class UserDao {
public void add() {
System.out.println("add ................");
}
}
创建service，有一个dao类对象作为属性（获取userDao对象还是用的老方法：ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");）：
package cn.service;
import cn.dao.UserDao;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class UserService {
private UserDao userDao;
public void setUserDao(UserDao userDao) {
this.userDao = userDao;
}
public void userSer() {
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
userDao = (UserDao) applicationContext.getBean("userDao");
userDao.add();
System.out.println("userSer ..........");
}
}
在index.jsp文件中加入代码：
<%
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
UserService user = (UserService) applicationContext.getBean("userService");
user.userSer();
%>applicationContext.xml文件：
<bean id="userDao" class="cn.dao.UserDao">
</bean>
<bean id="userService" class="cn.service.UserService">
<property name="userDao" ref="userDao"/>
</bean>运行显示效果
可以看出每次获取 ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml")；都要加载application.xml文件。
而每次刷新，都要获取一遍
这使得程序运行效率大大降低！
2.解决方案：
（1）我们可以将applicationContext.xml文件的加载过程放在和tomcat服务器启动的时候一起！
（2）原理：tomcat程序启动时会给程序初始化一个servletContext对象，我们可以使用监听器监听servletContext的初始化，使得在ServletContext被创建即tomcat启动时实例化一个spring容器，将所有配置了的bean都放进ServletContext中，我们获取bean时从servletContext中获取即可！监听器不需要我们自己写，spring-web包中给我们封装了这些功能！
（3）具体操作：
首先在web.xml文件中配置listener
<!--配置监听器-->
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>配置applicationContext.xml文件所在的位置（我是放在src目录文件下，所以是classpath:...）：
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:applicationContext.xml</param-value>
</context-param>配置文件完成了，我们怎么获得这些bean呢？方法有很多，写下我个人觉得比较好的方法：
创建一个类实现ApplicationContextAware接口：
package cn.utils;
import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
public class WebApplicationContextUtil implements ApplicationContextAware {
private static ApplicationContext applicationContext;
@Override
public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
WebApplicationContextUtil.applicationContext = applicationContext;
}
public static ApplicationContext getApplicationContext() {
return applicationContext;
}
@SuppressWarnings("unchecked")
public static <T> T getBean(String name) throws BeansException {
return (T) applicationContext.getBean(name);
}
}
最后在applicationContext.xml文件中添加：
<!--Spring容器会检测容器中的所有Bean，如果发现某个Bean实现了ApplicationContextAware接
口，Spring容器会在创建该Bean之后，自动调用该Bean的setApplicationContextAware()方法，
调用该方法时，会将容器本身作为参数传给该方法——该方法中的实现部分将Spring传入的参数（
容器本身）赋给该类对象的applicationContext实例变量，因此接下来可以通过该
applicationContext实例变量来访问容器本身。-->
<bean id="webApplicationContext" class="cn.utils.WebApplicationContextUtil">
</bean>获得bean时直接使用这个类的静态方法getBean即可：
UserService user = WebApplicationContextUtil.getBean("userService");
user.userSer();
userDao = WebApplicationContextUtil.getBean("userDao");
userDao.add();重启服务器（刷新多次都只是实例化spring容器一次）：
~~基于aspectJ的注解aop
一时半会儿还用不上，等用得上时再学再写。。。
~~jdbc Template实现增删改查操作
1.spring框架是一站式框架
（1）针对Javaee三成，每一层都有解决技术。
（2）在dao层，使用的是jdbcTemplate
2.spring对不同的持久化技术都进行了封装。
3.增加
（1）导入相关jar包（或者添加相关依赖）
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-tx</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>${spring.version}</version>
</dependency>别忘了数据库驱动的jar包
<!--mysql数据库驱动 -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.38</version>
</dependency>（2）写个测试类测试jdbc模板操作
（3）创建jdbcTemplate对象，设置数据源。
...这个写不下去了，，，发了就遛