spring ioc基础 对象 DI
基础
1.创建spring的web项目
2 .导包
3.编写基础的测试代码
controller层 MyServlet
package com.bjsxt.controller;
@WebServlet("/my")
public class MyServlet extends HttpServlet {
@Override
protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
//设置请求编码格式
//设置响应编码格式
//获取请求信息
//处理请求信息
//获取业务层对象---传统方案，在Servlet中直接获取，耦合性高。
//MyService myService=new MyServiceImpl2();
//myService.testService();
//SpringIOC的方式---导入jar包，
//获取Spring容器对象
ApplicationContext ac=new ClassPathXmlApplicationContext("applicationcontext.xml");
MyService myService = (MyService) ac.getBean("myService");
myService.testService();
//响应处理结果
}
}
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.xsd">
<!--配置资源对象-->
<bean id="myService" class="com.bjsxt.service.impl.MyServiceImpl2"></bean>
</beans>
MyServiceImpl2
package com.bjsxt.service.impl;
import com.bjsxt.service.MyService;
public class MyServiceImpl2 implements MyService {
@Override
public void testService() {
System.out.println("MyServiceImpl2.testService-----升级方法");
}
}
MyService
package com.bjsxt.service;
public interface MyService {
//测试业务方法
void testService();
}
4.测试 http://localhost:8080/my
对象
1.测试类编写
package com.bjsxt.controller;
import com.bjsxt.pojo.Student;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class TestIocObject {
public static void main(String[] args) {
//获取Spring容器对象
ApplicationContext ac=new ClassPathXmlApplicationContext("applicationcontext.xml");
//获取Spring容器中的对象
//1.构造器方式创建
//无参数构造器
Student student= (Student) ac.getBean("stu");
System.out.println("我是无参数构造器创建:"+student);
//有参数的构造器
Student student1= (Student) ac.getBean("stu2");
System.out.println("我是有参数构造器:"+student1);
//2.使用属性注入的方式
Student student2= (Student) ac.getBean("stu3");
System.out.println("我是属性注入方式："+student2);
//3.工厂模式
//动态工厂
Student student3= (Student) ac.getBean("stu4");
System.out.println("我是动态工厂方式:"+student3);
//动态工厂
Student student4= (Student) ac.getBean("stu5");
System.out.println("我是静态工厂方式:"+student4);
}
}
2.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.xsd">
<!--IOC创建对象的方法方式学习：Spring容器对象在被创建的时候，就完成了配置文件中类对象资源的初始化创建， 直接从容器中获取使用-->
<!--1、通过构造器方式-->
<!--无参数构造器:默认方式-->
<bean id="stu" class="com.bjsxt.pojo.Student"></bean>
<!--
有参数构造器:
在bean标签下使用constructor-arg子标签来声明要调用的有参数的构造器
一个constructor-arg子标签表示一个参数。constructor-arg仅仅表示参数的个数
但是参数数量相同的构造器可能会有很多，需要继续在constructor-arg标签上
使用属性来声明构造器的其他特点，目的保证Spring容器对象只能找到一个对应的构造器。
constructor-arg的属性
index属性:表示形参的角标
name属性:形参名
type属性:形参的类型，类型的全限定路径
value属性:初始化的值
缺陷:
必须要有对应的构造器
-->
<bean id="stu2" class="com.bjsxt.pojo.Student">
<constructor-arg index="0" name="sid" type="java.lang.Integer" value="1"></constructor-arg>
<constructor-arg index="1" name="sname" type="java.lang.String" value="张三"></constructor-arg>
</bean>
<!--
2、通过属性注入方式
相当于我们之前自己先创建一个空对象，然后调用set方法完成属性赋值。
注意:
必须提供属性的set/get方法
使用:
在bean标签下使用property子标签，一个property子标签表示调用一个set方法
使用property的属性来表明要调用的set方法:
name属性:对象中的属性名
value属性:值
-->
<bean id="stu3" class="com.bjsxt.pojo.Student">
<property name="sid" value="2"></property>
<property name="fav" value="唱歌"></property>
</bean>
<!--
3、通过工厂创建对象
本质：
Spring容器对象创建工厂，然后调用工厂生产对应的对象，存储到Spring容器中
从Spring容器中获取生产好的对象使用即可。
-->
<!--动态工厂方式:-->
<!--创建工厂对象-->
<bean id="factory" class="com.bjsxt.pojo.StudentFactory"></bean>
<!--生产对象-->
<bean id="stu4" factory-bean="factory" factory-method="newIntance"></bean>
<!--静态工厂-->
<bean id="stu5" class="com.bjsxt.pojo.StudentStaticFactory" factory-method="newIntance"></bean>
</beans>
3.Student StudentFactory StudentStaticFactory
package com.bjsxt.pojo;
import java.util.Objects;
public class Student {
private Integer sid;
private String sname;
private String fav;
@Override
public String toString() {
return "Student{" +
"sid=" + sid +
", sname='" + sname + '\'' +
", fav='" + fav + '\'' +
'}';
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Student student = (Student) o;
return Objects.equals(sid, student.sid) &&
Objects.equals(sname, student.sname) &&
Objects.equals(fav, student.fav);
}
@Override
public int hashCode() {
return Objects.hash(sid, sname, fav);
}
public Integer getSid() {
return sid;
}
public void setSid(Integer sid) {
this.sid = sid;
}
public String getSname() {
return sname;
}
public void setSname(String sname) {
this.sname = sname;
}
public String getFav() {
return fav;
}
public void setFav(String fav) {
this.fav = fav;
}
public Student() {
System.out.println("我是学生的无参数构造器");
}
public Student(Integer sid, String sname, String fav) {
this.sid = sid;
this.sname = sname;
this.fav = fav;
System.out.println("sid = " + sid + ", sname = " + sname + ", fav = " + fav);
}
public Student(Integer sid, String sname) {
this.sid = sid;
this.sname = sname;
System.out.println("sid = " + sid + ", sname = " + sname);
}
public Student(String fav ,Integer sid) {
this.sid = sid;
this.fav = fav;
System.out.println("fav = " + fav + ", sid = " + sid);
}
}
package com.bjsxt.pojo;
public class StudentFactory {
public Student newIntance(){
//声明Student对象创建的其他依赖资源
System.out.println("我是动态工厂");
return new Student();
}
}
package com.bjsxt.pojo;
public class StudentStaticFactory {
public static Student newIntance(){
//声明Student对象创建的其他依赖资源
System.out.println("我是静态工厂");
return new Student();
}
}
4.测试
从结果来看，都是spring对javabean进行实例化后，再执行测试方法！
DI
1.测试类编写
package com.bjsxt.controller;
import com.bjsxt.pojo.Student;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class TestIocDI {
public static void main(String[] args) {
//获取Spring容器对象
ApplicationContext ac=new ClassPathXmlApplicationContext("applicationcontext.xml");
//构造器依赖注入
//获取学生对象
Student student= (Student) ac.getBean("stu");
System.out.println("构造器依赖注入:"+student);
//属性依赖注入
Student student1= (Student) ac.getBean("stu2");
System.out.println("属性依赖注入:"+student1);
}
}
2.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.xsd">
<!--DI依赖注入-->
<!--构造器的依赖注入-->
<!--创建学生bean-->
<bean id="stu" class="com.bjsxt.pojo.Student">
<constructor-arg index="0" type="java.lang.Integer" name="sid" value="1"></constructor-arg>
<constructor-arg index="1" type="java.lang.String" name="sname" value="张三"></constructor-arg>
<constructor-arg index="2" type="java.lang.String" name="fav" value="唱歌"></constructor-arg>
<constructor-arg index="3" type="com.bjsxt.pojo.Teacher" name="teacher" ref="tea"></constructor-arg>
</bean>
<!--创建教师bean-->
<bean id="tea" class="com.bjsxt.pojo.Teacher">
<property name="tid" value="1"></property>
<property name="tname" value="张老师"></property>
</bean>
<!--属性依赖注入-->
<!--创建学生bean-->
<bean id="stu2" class="com.bjsxt.pojo.Student">
<property name="sid" value="2"></property>
<property name="sname" value="李四"></property>
<property name="fav" value="敲代码"></property>
<property name="teacher" ref="tea2"></property>
</bean>
<!--创建教师bean-->
<bean id="tea2" class="com.bjsxt.pojo.Teacher">
<property name="tid" value="2"></property>
<property name="tname" value="刘老师"></property>
</bean>
</beans>
3.Student Teacher
package com.bjsxt.pojo;
import java.util.Objects;
public class Student {
private Integer sid;
private String sname;
private String fav;
private Teacher teacher;
@Override
public String toString() {
return "Student{" +
"sid=" + sid +
", sname='" + sname + '\'' +
", fav='" + fav + '\'' +
", teacher=" + teacher +
'}';
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Student student = (Student) o;
return Objects.equals(sid, student.sid) &&
Objects.equals(sname, student.sname) &&
Objects.equals(fav, student.fav) &&
Objects.equals(teacher, student.teacher);
}
@Override
public int hashCode() {
return Objects.hash(sid, sname, fav, teacher);
}
public String getSname() {
return sname;
}
public void setSname(String sname) {
this.sname = sname;
}
public String getFav() {
return fav;
}
public void setFav(String fav) {
this.fav = fav;
}
public Teacher getTeacher() {
return teacher;
}
public void setTeacher(Teacher teacher) {
this.teacher = teacher;
}
public Integer getSid() {
return sid;
}
public void setSid(Integer sid) {
this.sid = sid;
}
public Student(Integer sid, String sname, String fav, Teacher teacher) {
this.sid = sid;
this.sname = sname;
this.fav = fav;
this.teacher = teacher;
}
public Student() {
}
}
package com.bjsxt.pojo;
import java.util.Objects;
public class Teacher {
private Integer tid;
private String tname;
@Override
public String toString() {
return "Teacher{" +
"tid=" + tid +
", tname='" + tname + '\'' +
'}';
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Teacher teacher = (Teacher) o;
return Objects.equals(tid, teacher.tid) &&
Objects.equals(tname, teacher.tname);
}
@Override
public int hashCode() {
return Objects.hash(tid, tname);
}
public Integer getTid() {
return tid;
}
public void setTid(Integer tid) {
this.tid = tid;
}
public String getTname() {
return tname;
}
public void setTname(String tname) {
this.tname = tname;
}
public Teacher() {
}
public Teacher(Integer tid, String tname) {
this.tid = tid;
this.tname = tname;
}
}
4.测试 ok!
问题与思考
1.对于项目中的重复代码如何合理解决？
① 不同的方法中出现了重复代码–>将重复代码封装为工具方法，然后
在自己的方法中调用工具方法，同时声明自己的代码。
② 不同的类中出现了重复的代码—>封装工具类
③ 不同的项目出现了重复代码—>封装jar包
2.jar包与源文件，压缩文件的比较思考？
jar包是直接可以使用的class文件，是功能文件。
jar包的本质:
其实就是代码的class文件的压缩包，jdk可以直接调用无需解压。
jar包的使用:
将jar包资源放入到项目中后，需要add as library.
jar包的特点:
在项目中引入其他已经完成的代码的同时，保证项目原有代码的结构层次。
3.谈一谈对框架的理解？
概念：
不同的项目会使用相同的代码进行开发。而这部分代码如果要进行封装
不是一个类或者一个方法就能搞定的，需要封装出来很多的类文件，于是
为了方便其他人使用，我们再次将这些代码封装为jar包，所以，框架其实
就是不用的项目都会使用的代码的封装，软件的半成品。
本质：框架就是别人封装好的功能代码。
集体表现形式：
一堆jar包：封装好了都要使用的代码。
使用：
① 将jar包导入到自己的项目中
② 查阅API文档，调用jar包中的资源完成功能开发
③ 配置框架的配置文件(框架代码运行需要的常量数据)
数据和代码的解耦，使用者可以通过配置类来自定义数据。
学习：
就是使用别人的代码完成自己的功能开发。其实就是学习
如何使用别人的代码。想当于javaSE阶段学习常用类。
4.谈一谈spring框架？
概念:Spring是一个控制反转(IOC)和面向切面的(AOP)的轻量级框架.
使用范围:任何java程序.
作用:
①简化企业项目的开发的流程.提升开发效率
②便于代码的后期维护升级.
③将代码之间的耦合性降低.
内容:
SpringIOC的使用
SpringAOP的使用
SpringTX的使用
注意:
Spring是一个框架集,内部集成了很多的功能,可以根据需求 选择对应的子框架使用.
结构：
发明人：Rod Johnson
5.为什么用springIOC?
问题:
在使用MVC的结构体系来完成后台功能代码的声明时,在一定程度上降低了代码的冗余,但是层与层之间的耦合性过高,造成代码升级维护特别麻烦,比如,某天业务层某个类文件需要替换为新的类文件,那么,控制层所有调用该业务类的代码需要全部修改为调用新的业务类.---------------接口非常重要！
解决:
将层与层对象之间的关系进行解耦,由直接变为间接.
实现:
SpringIOC.
作用:
实现了层与层之间对象的逻辑性的解耦.
6.springIOC的原理？
没有是多加一层解决不了的，IOC的原理其实就是反射，Controller层获取Service层的对象，不直接获取，而是通过applicationcontext.xml利用反射原理进行获取。key value形式,下次Controller层在代码不变的情况下，调用不同的service实现类，只需要在xml配置文件中修改即可！
扫一扫
487
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
