不积跬步无以至千里，后继才能薄发
本篇文章是我的SSM框架入门笔记，笔记内容基于黑马程序员的课程内容：点击打开
Spring是分层的Java SE、EE 应用的全栈轻量级开源框架，以IoC（inverse Of Control：控制反转）和AOP（Aspect OrientedProgramming：面向切面编程）为内核。
提供了视图层SpringMVC、持久层Spring JDBCTemplate以及业务层事务管理等众多的企业级应用技术，还能整合开源世界众多著名的第三方框架和类库，逐渐称为使用最多的Java EE企业应用开源框架。
这句话视频里抄下来的，我现在还不懂这是什么意思。
通过Spring提供的IoC容器，可以将对象间的依赖关系交由Spring惊醒控制，避免硬编码所造成的过度耦合。用户也不必再为单例模式类、属性文件解析等这些很底层的需求编写代码，可以更专注于上层应用。
通过Spring的AOP功能，方便进行面向切面编程，许多不容易用创痛OOP实现的功能都可以通过AOP实现。
这个听抽象的，我的水平还不够去理解！
可以将我们从单调烦闷的事务管理代码中解脱出来，通过声明式方式灵活的进行事务管理，提高开发效率和质量。
可以用非容器依赖的编程方式进行几乎所有的测试工作，测试不再是昂贵的操作，而是随手可做的事情。
Spring对各种优秀框架（Struts、Hibernate、Hessian、Quartz）的支持。
Spring对JavaEE API（如JDBC、JavaMail、远程调用等）进行了薄薄的封装层，使这些API的使用难度大为降低。
简单对比一下 javaweb 和 spring 的用法。
导入Spring开发包
//pom.xml文件org.springframework spring-context 5.0.5.RELEASE
Spring
├─.idea
│
└─spring_ioc
│ pom.xml
│ spring_ioc.iml
│
└─src
├─main
│ ├─java
│ └─resources
└─test
└─java上面个是项目的基本结构，下面的相关代码，按顺序操作。
//pom.xmlorg.springframework spring-context 5.0.5.RELEASE junit junit 4.12 test
//UserDao.java
package com.nothinglin.dao;
public interface UserDao {
public void save();
}//UserDaoImpl.java
package com.nothinglin.dao.impl;
import com.nothinglin.dao.UserDao;
public class UserDaoImpl implements UserDao {
//这里没写，实际有一个无参构造器
public void save(){
System.out.println("save running...");
}
}//applicationContext.xml
//firstSpringTest.java
public class firstSpring {
public static void main(String[] args) {
//加载Spring配置文件
ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");
//获取Spring容器中对应id下的内容
UserDao userDao = (UserDao)app.getBean("userDao");
//调用目标对象的方法
userDao.save();
}
}
基本属性：
id：Bean实例在Spring容器中的唯一标识
class：Bean的全限定名称
scope：指对象的作用范围（singleton、prototype、request、session、global session）
singleton和prototype之间的区别：
singleton：
//applicationContext.xml
public class firstSpring {
public static void main(String[] args) {
//加载Spring配置文件
ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");
//获取Spring容器中对应id下的内容
UserDao userDao1 = (UserDao)app.getBean("userDao");
UserDao userDao2 = (UserDao)app.getBean("userDao");
//调用目标对象的方法
// userDao.save();
System.out.println(userDao1);
System.out.println(userDao2);
}
}
当scope的取值为singleton值时，
Bean的实例化个数：1个
Bean的实例化时机：当Spring核心文件被加载时，实例化配置Bean实例
Bean的生命周期：
1.对象创建：当应用加载，创建容器时，对象就被创建了
2.对象运行：只要容器在，对象就一直活着
3.对象销毁：当应用写在，销毁容器时，对象就被销毁
prototype：
Bean的实例化个数：多个
Bean的实例化时机：当调用getBean（）方法时实例化Bean
1.对象创建：当使用对象时，创建新的对象实例
2.对象运行：只要对象在使用中，就一直活着
3.对象销毁：当对象长时间不用时，被Java的垃圾回收机制回收
inti-method 和 destroy-method的意义
init-method：指定类中的初始化方法的名称
destroy-method：指定类中销毁方法的名称
//applicationContext.xml
//UserDaoImpl.java
public class UserDaoImpl implements UserDao {
//无参构造器
public UserDaoImpl(){
System.out.println("UserDaoImpl创建...");
}
//初始化方法
public void init(){
System.out.println("初始化方法...");
}
//销毁方法
public void destroy(){
System.out.println("销毁方法...");
}
//普通方法
public void save(){
System.out.println("save running...");
}
}public class firstSpring {
public static void main(String[] args) {
//加载Spring配置文件
ClassPathXmlApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");
//获取Spring容器中对应id下的内容
UserDao userDao = (UserDao)app.getBean("userDao");
System.out.println(userDao);
app.close();
}
}
1.无参构造方法实例化
2.工厂静态方法实例化
3.工厂实例方法实例化
工厂实例化方法还没接触，无参构造方法实例化就是我们上面的那个spring程序一样，那个就是无参构造方法的方式来实例化对象。
工厂静态方法实例化：
//applicationContext.xml //静态工厂
//StaticFactory.java
//静态工厂
public class StaticFactory {
public static UserDao getUserDao(){
return new UserDaoImpl();
}
}//userdao接口
public interface UserDao {
public void save();
}//userdao实例化
public class UserDaoImpl implements UserDao {
//无参构造器
public UserDaoImpl(){
System.out.println("UserDaoImpl创建...");
}
//普通方法
public void save(){
System.out.println("save running...");
}
}public class firstSpring {
public static void main(String[] args) {
//加载Spring配置文件
ClassPathXmlApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");
//获取Spring容器中对应id下的内容
//静态工厂实例化
UserDao userDao = (UserDao)app.getBean("userDao");
//调用目标对象的方法
userDao.save();
}
}
工厂实例方法实例化：
//applicationContext.xml //实例工厂实例化bean对象
//DynamicFactory.java
//实例工厂
public class DynamicFactory {
public UserDao getUserDao(){
return new UserDaoImpl();
}
}//userdao接口
public interface UserDao {
public void save();
}//userdao实例化
public class UserDaoImpl implements UserDao {
//无参构造器
public UserDaoImpl(){
System.out.println("UserDaoImpl创建...");
}
//普通方法
public void save(){
System.out.println("save running...");
}
}public class firstSpring {
public static void main(String[] args) {
//加载Spring配置文件
ClassPathXmlApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");
//获取Spring容器中对应id下的内容
//静态工厂实例化
UserDao userDao = (UserDao)app.getBean("userDao");
//调用目标对象的方法
userDao.save();
}
}对比了上面的几种方法，我在想：这三种方式存在的意义在哪？我还没搞明白这个。
通过观察上面的代码可以发现有个地方是可以进行优化，那就是配置文件的加载。对于配置文件加载这种繁琐的工作，应该交由service层去完成。
Spring
│
├─main
│ ├─java
│ │ └─com
│ │ └─nothinglin
│ │ ├─dao
│ │ │ │ UserDao.java
│ │ │ │
│ │ │ └─impl
│ │ │ UserDaoImpl.java
│ │ │
│ │ ├─factory
│ │ │ DynamicFactory.java
│ │ │ StaticFactory.java
│ │ │
│ │ └─service
│ │ │ UserService.java
│ │ │
│ │ └─impl
│ │ UserServiceImpl.java
│ │
│ └─resources
│ applicationContext.xml
│
└─test
└─java
firstSpring.java//applicationContext.xml
public interface UserDao {
public void save();
}public class UserDaoImpl implements UserDao {
//无参构造器
public UserDaoImpl(){
System.out.println("UserDaoImpl创建...");
}
//初始化方法
public void init(){
System.out.println("初始化方法...");
}
//销毁方法
public void destroy(){
System.out.println("销毁方法...");
}
//普通方法
public void save(){
System.out.println("save running...");
}
}public interface UserService {
public void save();
}public class UserServiceImpl implements UserService {
public void save() {
ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");
UserDao userDao = (UserDao) app.getBean("userDao");
userDao.save();
}
}public class SpringTest {
public static void main(String[] args) {
UserService userService = new UserServiceImpl();
userService.save();
}
}通过观察可以发现，这个service层更像是封装起一些繁琐的方法而存在的。
days
hours
minutes
seconds
