解析Spring第一天

目的：了解spring框架中的注解

前言：同样是使用idea创建一个普通的maven工程（如何创建一个普通的Maven工程可以参考mybatis入门第一天的详解）。

项目结构：

代码编辑：

在项目中引入需要的Maven开发坐标

 <dependencies>

         <dependency>

             <groupId>org.springframework</groupId>

             <artifactId>spring-context</artifactId>

             <version>5.0.2.RELEASE</version>

         </dependency>

         <dependency>

             <groupId>commons-logging</groupId>

             <artifactId>commons-logging</artifactId>

             <version>1.2</version>

         </dependency>

         <dependency>

             <groupId>log4j</groupId>

             <artifactId>log4j</artifactId>

             <version>1.2.12</version>

         </dependency>

         <dependency>

             <groupId>junit</groupId>

             <artifactId>junit</artifactId>

             <version>4.12</version>

             <scope>test</scope>

         </dependency>

     </dependencies>

在demo文件下编写接口UserService

 package zh.test.deomo;

 public interface UserService {

     public  void  sayHi();

 }

实现接口，编写UserServiceImpl

 package zh.test.deomo;

 public class UserServiceImpl implements UserService {

     public void sayHi() {

         System.out.println("SayHi");

     }

 }

载demo1文件下，编写关于spring使用setter的方式注入

　　创建一个DeptDao的接口

 package zh.test.deomo1;

 public interface DeptDao {

     public void save();

 }

　　实现该接口，DeptDaoImpl

 package zh.test.deomo1;

 public class DeptDaoImpl implements DeptDao {

     public void save() {

         System.out.println("持久层。。保存。。。");

     }

 }

　　编写DeptService的接口

 package zh.test.deomo1;

 public interface DeptService {

     public  void save();

 }

实现接口DeptServiceImpl

 package zh.test.deomo1;

 public class DeptServiceImpl implements DeptService {

     private DeptDao deptDao;

     //普通的数据类型,也需要提供set的方法注入

     private String name;

     private int age;

     public void setName(String name) {

         this.name = name;

     }

     public void setAge(int age) {

         this.age = age;

     }

     //依赖注入通过set的方法传递进来

     public void setDeptDao(DeptDao deptDao) {

         System.out.println("set被调用。。。");

         this.deptDao = deptDao;

     }

     public void save() {

         System.out.println("业务层。。。保存");

         System.out.println(name+":"+age);

         deptDao.save();

     }

 }

在deomo2的文件下编写关于使用构造函数的方式注入Car.java文件

 package zh.test.deomo2;

 public class Car {

     private String name;

     private Double money;

     public String getName() {

         return name;

     }

     public void setName(String name) {

         this.name = name;

     }

     public Double getMoney() {

         return money;

     }

     public void setMoney(Double money) {

         this.money = money;

     }

     @Override

     public String toString() {

         return "Car{" +

                 "name='" + name + '\'' +

                 ", money=" + money +

                 '}';

     }

     public Car(String name, Double money) {

         this.name = name;

         this.money = money;

     }

 }

在deomo4文件下编写扩展的类，主要是存放集合、数组、属性文件

 package zh.test.deomo4;

 import java.util.Arrays;

 import java.util.List;

 import java.util.Map;

 import java.util.Properties;

 public class Extension {

     //数组

     private String [] strs;

     //集合

     private List<String> list;

     //map

     private Map<String,String> map;

     //属性文件

     private Properties properties;

     @Override

     public String toString() {

         return "Extension{" +

                 "strs=" + Arrays.toString(strs) +

                 ", list=" + list +

                 ", map=" + map +

                 ", properties=" + properties +

                 '}';

     }

     public String[] getStrs() {

         return strs;

     }

     public void setStrs(String[] strs) {

         this.strs = strs;

     }

     public List<String> getList() {

         return list;

     }

     public void setList(List<String> list) {

         this.list = list;

     }

     public Map<String, String> getMap() {

         return map;

     }

     public void setMap(Map<String, String> map) {

         this.map = map;

     }

     public Properties getProperties() {

         return properties;

     }

     public void setProperties(Properties properties) {

         this.properties = properties;

     }

 }

编写applicationContxt.xml文件在resources目录下

 <?xml version="1.0" encoding="UTF-8"?>

 <beans xmlns="http://www.springframework.org/schema/beans"

        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:util="http://www.springframework.org/schema/util"

        xsi:schemaLocation="http://www.springframework.org/schema/beans

                     http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd">

     <!--IOC管理bean-->

     <!--配置实现类，配置组建bean管理-->

     <!--

     标签bean  用来管理类，把类交给IOC容器管理，IOC容器把当前的这个类创建对象，存入到IOC容器中。

     id="唯一的值，自定义"

     class="管理类的全路径，包名+类名    底层使用反射代码创建对象"

     class.forName("zh.test.deomo.UserServiceImpl")

     scope="是创建之后的对象是单例的还是多例的"  默认是单例的

     scope="singleton" 单例的

     scope="prototype"  多例的

     区别：如果是多例的在程序加载配置文件的时候不会立即创建一个对象，而是什么时候用到什么时候会用到。

          如果是单例的则是在程序已加载的时候就会创建一个对象。只要IOC的容器存在那么单例的对象就一直存在。

     -->

     <bean id="userService" class="zh.test.deomo.UserServiceImpl" />

     <!--通过set的方法注入-->

     <bean id="deptService" class="zh.test.deomo1.DeptServiceImpl">

         <!--依赖注入 name="service中的属性"-->

         <property name="deptDao" ref="deptDao"/>

         <!--给普通的属性注入值-->

         <property name="name" value="白天黑天阴天"/>

         <property name="age" value="20"/>

     </bean>

     <bean id="deptDao" class="zh.test.deomo1.DeptDaoImpl"></bean>

     <!--属性的构造方法-->

     <bean id="car" class="zh.test.deomo2.Car">

         <constructor-arg name="name" value="劳斯劳斯"/>

         <constructor-arg name="money" value="11111"/>

     </bean>

     <!--扩展方法-->

     <bean id="extension" class="zh.test.deomo4.Extension">

         <!--数组-->

         <property name="strs">

             <array>

                 <value>l</value>

                 <value>g</value>

             </array>

         </property>

         <!--集合-->

         <property name="list">

             <list>

                 <value>james</value>

                 <value>davis</value>

             </list>

         </property>

         <!--map-->

         <property name="map">

             <map>

                 <entry key="lakers" value="lebron"/>

                 <entry key="lakers1" value="davis"/>

             </map>

         </property>

         <!--属性文件-->

         <property name="properties">

             <props>

                 <prop key="lakers">london</prop>

                 <prop key="lakers1">kuzma</prop>

             </props>

         </property>

     </bean>

 </beans>

最后写一个测试的方法，对以上的注入进行测试

 package zh.test;

 import org.junit.Test;

 import org.springframework.context.ApplicationContext;

 import org.springframework.context.support.ClassPathXmlApplicationContext;

 import zh.test.deomo.UserService;

 import zh.test.deomo.UserServiceImpl;

 import zh.test.deomo1.DeptService;

 import zh.test.deomo2.Car;

 import zh.test.deomo4.Extension;

 public class testDemo {

     @Test

     public  void test()

     {

         //原始写法：

         UserServiceImpl userService = new UserServiceImpl();

         userService.sayHi();

         //使用Spring框架

     }

     @Test

     public void testSpring(){

         //创建SpringIOC的工厂（容器） ，需要加载配置文件，就会将配置文件中的类通过反射的方式创建成对象

         //将对象存入到容器中，以key : value 的方式，k="userService"  v="UserServiceImpl对象（默认是单例的）"

         //

         ApplicationContext ac=new ClassPathXmlApplicationContext("applicationContext.xml");

         //从容器中获取对象  面向接口的编程

         UserService userService = (UserService) ac.getBean("userService");

         //调用对象

         userService.sayHi();

     }

 //    setter的方式注入

     @Test

     public void testSpringDI(){

         //创建SpringIOC的工厂（容器） ，需要加载配置文件，就会将配置文件中的类通过反射的方式创建成对象

         //将对象存入到容器中，以key : value 的方式，k="userService"  v="UserServiceImpl对象（默认是单例的）"

         //

         ApplicationContext ac=new ClassPathXmlApplicationContext("applicationContext.xml");

         //从容器中获取对象  面向接口的编程

         DeptService deptService = (DeptService) ac.getBean("deptService");

         //调用对象

         deptService.save();

     }

 //    属性的构造方法注入

     @Test

     public void testCar(){

         ApplicationContext ac=new ClassPathXmlApplicationContext("applicationContext.xml");

         //从容器中获取对象  面向接口的编程

         Car car = (Car) ac.getBean("car");

         //调用对象

         System.out.println(car);

     }

     //扩展方法  数组、集合、map、属性文件

     @Test

     public void testExtension(){

         ApplicationContext ac=new ClassPathXmlApplicationContext("applicationContext.xml");

         //从容器中获取对象  面向接口的编程

         Extension extension = (Extension) ac.getBean("extension");

         //调用对象

         System.out.println(extension);

     }

 }

分享之路，欢迎交流。。。

巴特西

解析Spring第一天

最新文章

热门文章