• 近期将进行后台系统升级,如有访问不畅,请稍后再试!
  • 极客文库-知识库上线!
  • 极客文库小编@勤劳的小蚂蚁,为您推荐每日资讯,欢迎关注!
  • 每日更新优质编程文章!
  • 更多功能模块开发中。。。

Java后端的学习之Spring基础

Java 后端的学习之 Spring 基础
如果要学习spring,那么什么是框架,spring又是什么呢?学习spring中的iocbean,以及aop,IOC,Bean,AOP,(配置,注解,api)-springFramework.
图片说明

各种学习的知识点:
spring expression language
spring integration
spring web flow
spring security
spring data
spring batch

spring网站:
图片说明

图片说明

spring是一种开源框架,是为了解决企业应用开发的复杂性问题而创建的,现在的发展已经不止于用于企业应用了.
spring是一种轻量级的控制反转(IoC)和面向切面(AOP)的容器框架.
一句名言:spring带来了复杂的javaee开发的春天.
spring网站:
http://spring.io/

效果
http://spring.io/projects/spring-framework
效果
spring是一种开源框架,是为了解决企业应用开发的复杂性问题而创建的,现在的发展已经不止于用于企业应用了.

spring是一种轻量级的控制反转(IoC)和面向切面(AOP)的容器框架.

一句名言:spring带来了复杂的javaee开发的春天.

springmvc+spring+hibernate/ibatis->企业应用

什么是框架,为什么要用框架:

什么是框架:
图片说明

图片说明

框架就是别人制定好的一套规则和规范,大家在这个规范或者规则下进行工作,可以说,别人盖好了楼,让我们住.
图片说明

图片说明

软件框架是一种半成品,具有特定的处理流程和控制逻辑,成熟的,可以不断升级和改进的软件.
使用框架重用度高,开发效率和质量的提高,容易上手,快速解决问题.
spring ioc容器
图片说明

接口,是用于沟通的中介物的,具有抽象化,java中的接口,就是声明了哪些方法是对外公开的.
面向接口编程,是用于隐藏具体实现的组件.
案例:
// 声明一个接口
publicinterfaceDemoInterface{
String hello(String text);
// 一个 hello 方法,接收一个字符串型的参数,返回一个`String`类型.
}
// 实现
publicclassOneInterfaceimplementsDemoInterface{
@Override
public String hello(String text){
 return“你好啊: “ + text;
}
}
// 测试类
publicclassMain{
publicstaticvoidmain(String[] args){
 DemoInterface demo = new OneInterface();
 System.out.println(demo.hello(“dashucoding”);
}
}

什么是IOC,IOC是控制反转,那么什么控制反转,控制权的转移,应用程序不负责依赖对象的创建和维护,而是由外部容器负责创建和维护.

<?xml version=“1.0” encoding=“UTF-8”?>
<beanid=“oneInterface”class=“com.ioc.interfaces.OneInterfaceImpl”></bean>
</beans>

spring.xml
测试:
import org.junit.Test;
@RunWith(BlockJUnit4ClassRunner.class)
publicclassTestOneInterfaceextendsUnitTestBase{
publicTestOneInterface(){
 super(“spring.xml”);
}
@Test
publicvoidtestHello(){
 OneInterface oneInterface = super.getBean(“oneInterface”);
 System.out.println(oneInterface.hello(“dashucoding”));
}

}

单元测试
下载一个包junit-*.jar导入项目中,然后创建一个UnitTestBase类,用于对spring进行配置文件的加载和销毁,所有的单元测试都是继承UnitTestBase的,然后通过它的getBean方法获取想要的对象,子类要加注解@RunWith(BlockJUnit4ClassRunner.class),单元测试方法加注解@Test.
public ClassPathXmlApplicationContext context;
publicString springXmlpath;
public UnitTestBase(){}
public UnitTestBase(String springXmlpath){
 this.springXmlpath = springXmlpath;
}
@Before
publicvoid before(){
if(StringUtils.isEmpty(springXmlpath)){
 springXmlpath = “classpath*:spring-*.xml”;
}
try{
 context = new ClassPathXmlApplicationContext(springXmlpath.split(“[,s]+”));
 context.start();
}catch(BeansException e){
 e.printStackTrace();
}
}
@After
publicvoid after(){
 context.destroy();
}
@SuppressWarnings(“unchecked”)
protected <T extendsObject> T getBean(String beanId){
 return (T)context.getBean(beanId);
}
protected <T extendsObject> T getBean(Class<T> clazz){
 return context.getBean(clazz);
}
}

bean容器:
org.springframework.beansorg.springframework.context
BeanFactory提供配置结构和基本功能,加载并初始化Bean,ApplicationContext保存了Bean对象.
// 文件
FileSystemXmlApplicationContext context = new FileSystemXmlApplicationContext(“D:/appcontext.xml”);
// Classpath
ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext(“classpath:spring-context.xml”);
// Web 应用
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
<servlet>
<servlet-name>context</servlet-name>
<servlet-class>org.springframework.web.context.ContextLoaderServlet</servlet-class>
<load-on-startup>1</load-on-startup>
</servlet>

spring注入:启动spring加载bean的时候,完成对变量赋值的行为.注入方式:设值注入和构造注入.

// 设值注入
<?xml version=“1.0” encoding=“UTF-8”?>
<beanid=“iService”class=“com.service.iServiceImpl”>
 <propertyname=“iDAO”ref=“DAO”/>
</bean>
<beanid=“DAO”class=“com.iDAOImpl”></bean>
</beans>

// 构造注入
<?xml version=“1.0” encoding=“UTF-8”?>
<beanid=“iService”class=“com.service.iServiceImpl”>
 <constructor-argname=“DAO”ref=“DAO”/>
 <propertyname=“injectionDAO”ref=“injectionDAO”></property>
</bean>
<beanid=“DAO”class=“com.iDAOImpl”></bean>
</beans>

spring注入:

<?xml version=“1.0” encoding=“UTF-8”?>
<beanid=“injectionService”class=“com.injection.service.InjectionServiceImpl”></bean>
<beanid=“injectionDAO”class=“com.ijection.dao.InjectionDAOImpl”></bean>
</beans>

// 接口-业务逻辑
publicinterfaceInjectionService {
publicvoidsave(String arg);

}


// 实现类-处理业务逻辑
publicclassInjectionServiceImplimplementsInjecionService{
private InjectionDAO injectionDAO;
publicInjectionServiceImpl(InjectionDAO injectionDAO){
 this.injectionDAO = injectionDAO;
}
publicvoidsetInjectionDAO(InjectiionDAO injectionDAO){
 this.injectionDAO = injectionDAO;
}
publicvoidsave(String arg){
 System.out.println(“接收” + arg);
 arg = arg + “:” + this.hashCode();
 injectionDAO.save(arg);
}
}

// 接口-数据库-调用 DAO
publicinterfaceInjectionDAO {
// 声明一个方法
publicvoidsave(String arg);

}


// 实现类
publicclassInjectionDAOImplimplementsInjectionDAO{
// 实现接口中的方法
publicvoidsave(String arg){
 System.out.println(“保存数据” + arg);
}
}

// 测试
import org.junit.Test;
@RunWith(BlockJUnit4ClassRunner.class)
publicclassTestInjectionextendsUnitTestBase{
publicTestInjection(){
 super(“classpath:spring-injection.xml”);
}
@Test
publicvoid  testSetter(){
 InjectionService service = super.getBean(“injectionService”);
 service.save(“保存的数据”);
}
@Test
publicvoidtestCons(){
 InjectionService service = super.getBean(“injectionService”);
 service.save(“保存的数据”);
}

}


bean的配置:

id:id 是整个 ioc 容器中,bean 的标识
class:具体要实例化的类
scope:作用域
constructor  arguments:构造器的参数
properties:属性
autowiring mode:自动装配的模式
lazy-initialization mode:懒加载模式
Initialization/destruction method:初始化和销毁的方法

作用域

singleton:单例
prototype:每次请求都创建新的实例
request:每次 http 请求都创建一个实例有且当前有效
session:同上

spring bean配置之Aware接口:spring中提供了以Aware结尾的接口,为spring的扩展提供了方便.
bean的自动装配autowiring
no是指不做任何操作
byname 是根据自己的属性名自动装配
byType 是指与指定属性类型相同的 bean 进行自动装配,如果有过个类型存在的 bean,那么就会抛出异常,不能使用 byType 方式进行自动装配,如果没有找到,就不什么事都不会发生
Constructor 是与 byType 类似,它是用于构造器参数的,如果没有找到与构造器参数类型一致的 bean 就会抛出异常

spring bean配置的resource

resources:
urlresource 是 url 的资源
classpathresource 是获取类路径下的资源
filesystemresource 是获取文件系统的资源
servletcontextresource 是 servletcontext 封装的资源
inputstreamresource 是针对输入流封装的资源
bytearrayresource 是针对字节数组封装的资源

publicinterfaceResourceLoader{
Resource getResource(String location);

}


ResourceLoader

classpath: Loaded from the classpath;
file: Loaded as a URL, from the filesystem;
http: Loaded as a URL;

案例:

publicclassMResourceimplementsApplicationContextAware{
 private ApplicationContext applicationContext;
@Override
publicvoidsetApplicationContext(ApplicationContext applicationContext)throws BeansException {
this.applicationContext = applicationContext;
}
publicvoidresource(){
 Resource resource = applicationContext.getResource(“classpath:config.txt”);
 System.out.println(resource.getFilename());
}
}

// 单元测试类
import com.test.base.UnitTestBase;
@RunWith(BlockJUnit4ClassRunner.class)
publicclassTestResourceextendsUnitTestBase{
publicTestResource(){
 super(“classpath:spring-resource.xml”);
}
@Test
publicvoidtestResource(){
 MResource resource = super.getBean(“mResource”);
 try{
  resource.resource();
 }catch(IOException e){
  e.printStackTrace();
 }
}

}


<?xml version=“1.0” encoding=“UTF-8”?>
<beanid=“moocResource”class=“com.resource.MResource”></bean>
</beans>

bean的定义与学习:

<context:annotation-config/>
@Component,@Repository,@Service,@Controller
@Required,@Autowired,@Qualifier,@Resource

@Configuration,@Bean,@Import,@DependsOn
@Component,@Repository,@Service,@Controller

  1. @Repository用于注解DAO类为持久层
  2. @Service用于注解Service类为服务层
  3. @Controller用于Controller类为控制层
元注解Meta-annotationsspring提供的注解可以作为字节的代码叫元数据注解,处理value(),元注解可以有其他的属性.
spring可以自动检测和注册bean
@Service
publicclassSimpleMovieLister{
private MovieFinder movieFinder;
@Autowired
publicSimpleMovieLister(MovieFinder movieFinder){
 this.movieFinder = movieFinder;
}
}

@Repository
publicclassJpaMovieFinderimplementsMovieFinder{

}


类的自动检测以及Bean的注册

<?xml version=“1.0” encoding=“UTF-8”?>
<context:component-scanbase-package=“org.example”/>
</beans>

类被自动发现并注册bean的条件:

@Component,@Repository,@Service,@Controller注解或者使用@Component的自定义注解

@Required用于bean属性的setter方法
@Autowired注解

private MovieFinder movieFinder;
@Autowired
publicvoidsetMovieFinder(MovieFinder movieFinder){
this.movieFinder = movieFinder;
}
用于构造器或成员变量
@Autowired
private MovieCatalog movieCatalog;
private CustomePreferenceDap customerPreferenceDao;
@Autowired
publicMovieRecommender(CustomerPreferenceDao customerPreferenceDao){
this.customerPreferenceDao = customerPreferenceDao;
}

@Autowired注解
使用这个注解,如果找不到bean将会导致抛出异常,可以使用下面代码避免,每个类只能有一个构造器被标记为required=true.
publicclassSimpleMovieLister{
private MovieFinder movieFinder;
@Autowired(required=false)
publicvoidsetMovieFinder(MovieFinder movieFinder){
 this.movieFinder = movieFinder;
}

}


spring是一个开源框架,spring 是用 j2ee 开发的 mvc 框架,spring boot 呢就是一个能整合组件的快速开发框架,因为使用 maven 管理,所以很便利。至于 spring cloud,就是微服务框架了。
spring是一个轻量级的Java开发框架,是为了解决企业应用开发的复杂性而创建的框架,框架具有分层架构的优势.
spring这种框架是简单性的,可测试性的和松耦合的,spring框架,我们主要是学习控制反转IOC和面向切面AOP.
// 知识点
spring ioc
spring aop
spring orm
spring mvc
spring webservice
spring transactions
spring jms
spring data
spring cache
spring boot
spring security
spring schedule

spring ioc为控制反转,控制反向,控制倒置,
图片说明

图片说明

图片说明

Spring容器是 Spring 框架的核心。spring容器实现了相互依赖对象的创建,协调工作,对象只要关系业务逻辑本身,IOC最重要的是完成了对象的创建和依赖的管理注入等,控制反转就是将代码里面需要实现的对象创建,依赖的代码,反转给了容器,这就需要创建一个容器,用来让容器知道创建对象与对象的关系.(告诉 spring 你是个什么东西,你需要什么东西)
xml,properties 等用来描述对象与对象间的关系
classpath,filesystem,servletContext 等用来描述对象关系的文件放在哪里了.

控制反转就是将对象之间的依赖关系交给了容器管理,本来是由应用程序管理的对象之间的依赖的关系.
spring ioc体系结构
BeanFactory
BeanDefinition

spring iocspring的核心之一,也是spring 体系的基础,在spring中主要用户管理容器中的bean.springIOC容器主要使用DI方式实现的.BeanFactory是典型的工厂模式,ioc容器为开发者管理对象间的依赖关系提供了很多便利.在使用对象时,要new object()来完成合作.ioc:spring容器是来实现这些相互依赖对象的创建和协调工作的.(由spring`来复杂控制对象的生命周期和对象间的)
所有的类的创建和销毁都是由spring来控制,不再是由引用它的对象了,控制对象的生命周期在spring.所有对象都被spring控制.
ioc容器的接口(自己设计和面对每个环节):
BeanFactory工厂模式
publicinterface BeanFactory {
String FACTORY_BEAN_PREFIX = “&”;
Object getBean(String name) throws BeansException;
Object getBean(String name, Class requiredType) throws BeansException;

boolean containsBean(String name);
boolean isSingleton(String name) throws NoSuchBeanDefinitionException;
Class getType(String name) throws NoSuchBeanDefinitionException;
String[] getAliases(String name);
}

BeanFactory三个子类:ListableBeanFactory,HierarchicalBeanFactoryAutowireCapableBeanFactory,实现类是DefaultListableBeanFactory.
控制反转就是所有的对象都被spring控制.ioc动态的向某个对象提供它所需要的对象.通过DI依赖注入来实现的.如何实现依赖注入ID,在Java中有一特性为反射,它可以在程序运行的时候进行动态的生成对象和执行对象的方法,改变对象的属性.
publicstaticvoidmain(String[] args){
ApplicationContext context = new FileSystemXmlApplicationContext(“applicationContext.xml”);
Animal animal = (Animal)context.getBean(“animal”);
animal.say();

}


// applicationContext.xml
<bean id=“animal”class=“com.test.Cat”>
<propertyname=“name”value=“dashu”/>
</bean>

publicclassCatimplementsAnimal{
private String name;
publicvoidsay(){
 System.out.println(“dashu”);
}
publicvoidsetName(String name){
 this.name = name;
}
}

publicinterfaceAnimal {
publicvoidsay();

}


// bean
privateString id;
privateStringtype;
private Map<String,Object> properties=new HashMap<String, Object>();

<bean id=“test”class=“Test”>
<propertyname=“testMap”>

</property>
</bean>

publicstaticObject newInstance(String className) {
Class<?> cls = null;
Object obj = null;
try {
 cls = Class.forName(className);
 obj = cls.newInstance();
} catch (ClassNotFoundException e) {
 thrownew RuntimeException(e);
} catch (InstantiationException e) {
 thrownew RuntimeException(e);
} catch (IllegalAccessException e) {
 thrownew RuntimeException(e);
}
return obj;

}

核心是控制反转(IOC)和面向切面(AOP),spring是一个分层的JavaSE/EE的轻量级开源框架.
web:
struts,spring-mvc

service:

spring

dao:

mybatis,hibernate,jdbcTemplate,springdata

spring体系结构

ioc
// 接口
publicinterfaceUserService{
publicvoidaddUser();
}
// 实现类
publicclassUserServiceImplimplementsUserService{
@Override
publicvoidaddUser(){
 System.out.println(“dashucoding”);
}
}

配置文件:

<?xml version=“1.0” encoding=“UTF-8”?>
      xsi:schemaLocation=http://www.springframework.org/schema/beans

   <beanid=“userServiceId”class=“com.dashucoding.UserServiceImpl”></bean>
</beans>

测试:

@Test
publicvoid demo(){
   String xmlPath = “com/beans.xml”;
   ApplicationContext applicationContext = new ClassPathXmlApplicationContext(xmlPath);
   UserService userService = (UserService) applicationContext.getBean(“userServiceId”);
   userService.addUser();

}

依赖注入:

classDemoServiceImpl{
private daDao daDao;
}

创建service实例,创建dao实例,将dao设置给service.
接口和实现类:
publicinterfaceBookDao{
   publicvoidaddBook();
}
publicclassBookDaoImplimplementsBookDao{
   @Override
   publicvoidaddBook(){
       System.out.println(“dashucoding”);
   }

}

publicinterfaceBookService{
   publicabstractvoidaddBook();
}
publicclassBookServiceImplimplementsBookService{
   private BookDao bookDao;
   publicvoidsetBookDao(BookDao bookDao){
       this.bookDao = bookDao;
   }
   @Override
   publicvoidaddBook(){
       this.bookDao.addBook();
   }
}

配置文件:

      xsi:schemaLocation=http://www.springframework.org/schema/beans
   <beanid=“bookServiceId”class=“com.BookServiceImpl”>
       <propertyname=“bookDao”ref=“bookDaoId”></property>
   </bean>
   
   <beanid=“bookDaoId”class=“com.BookDaoImpl”></bean>
</beans>

测试:

@Test
publicvoid demo(){
   String xmlPath = “com/beans.xml”;
   ApplicationContext applicationContext = new ClassPathXmlApplicationContext(xmlPath);
   BookService bookService = (BookService) applicationContext.getBean(“bookServiceId”);
       
   bookService.addBook();

}

IDE建立Spring项目

File—>new—>project—>Spring

// Server.java
publicclassServer {
privete String name;
publicvoidsetName(String name){
 this.name = name;
}
publicvoidputName(){
 System.out.println(name);
}
}

// Main.java
publicclassMain{
publicstaticvoidmain(String[] args){
 ApplicationContext context = new ClassPathXmlApplicationContext(“spring-config.xml”);
 Server hello = (Server)context.getBean(“example_one”);
 hello.putName();
}

}

spring-config.xml:

      xsi:schemaLocation=http://www.springframework.org/schema/beans
<beanid=“example_one”class=“Server”>
 <propertyname=“name”value=“达叔小生”></property>
</bean>
</beans>

使用Maven来声明Spring库.Maven是一个项目管理的工具,maven提供了开发人员构建一个完整的生命周期框架.Maven的安装和配置,需要的是JDK 1.8,Maven,Windows,配置jdk,JAVA_HOME变量添加到windows环境变量.下载Apache Maven,添加 M2_HOME 和 MAVEN_HOME,添加到环境变量PATH,值为%M2_HOME%in.执行mvn –version命令来显示结果.
Maven启用代理进行访问,找到文件路基,找到/conf/settings.xml,填写代理,要阿里的哦.
Maven中央存储库地址:
图片说明

// xml
<dependency>
      <groupId>org.jvnet.localizer</groupId>
       <artifactId>localizer</artifactId>
       <version>1.8</version>
</dependency>

// pom.xml
<repositories>
   <repository>
       <id>java.net</id>
   </repository>
</repositories>

Maven添加远程仓库:

// pom.xml
<project>
<repositories>
   <repository>
     <id>java.net</id>
   </repository>
</repositories>
</project>

<project>
   <repositories>
     <repository>
   <id>JBoss repository</id>
     </repository>
   </repositories>
</project>

Maven依赖机制,使用Maven创建Java项目.

<dependency>
   <groupId>junit</groupId>
   <artifactId>junit</artifactId>
   <version>4.11</version>
   <scope>test</scope>
</dependency>

Maven打包:

<project>
   <modelVersion>4.0.0</modelVersion>
   <groupId>com.dashucoding</groupId>
   <artifactId>NumberGenerator</artifactId>    
   <packaging>jar</packaging>  
   <version>1.0-SNAPSHOT</version>

spring框架:

图片说明

publicinterfaceHelloWorld{
publicvoidsayHello();
}
publicclassSpringHelloWorldimplementsHelloWorld{
publicvoidsayHello(){
 System.out.println(Spring Hello”);
}
}

publicclassStrutsHelloWorldimplementsHelloWorld{
publicvoidsayHello(){
 System.out.println(“Struts Hello”);
}
}

publicclassHelloWorldServie{
private HelloWorld helloWorld;
publicHelloWorldService(){
 this.helloWorld = new StrutsHelloWorld();
}
}

控制反转:

publicclassHelloWorldService{
private HelloWorld helloWorld;
publicHelloWorldService(){
}
publicvoidsetHelloWorld(HelloWorld helloWorld){
 this.helloWorld = helloWorld;
}
public HelloWorld getHelloWorld(){
 returnthis.helloWorld;
}

}

ioc创建了HelloWorldService对象.

spring->HelloProgram.java
helloworld->
HelloWorld.java
HelloWorldService.java
impl 实现类->
SpringHelloWorld.java
StrutsHelloWorld.java
resources->beans.xml
// 总结
一个 spring:HelloProgram.java
接口:
实现类:
资源:beans.xml

// HelloWorld.java
publicinterfaceHelloWorld {
publicvoidsayHello();
}
// public class HelloWorldService {
private HelloWorld helloWorld;
publicHelloWorldService(){
}
publicvoidsetHelloWorld(HelloWorld helloWorld){
 this.helloWorld = helloWorld;
}
public HelloWorld getHelloWorld(){
 returnthis.helloWorld;
}
}

// SpringHelloWorld.java
publicclassSpringHelloWorldimplementsHelloWorld{
 
   @Override
   publicvoidsayHello(){
       System.out.println(“Spring Hello!”);
   }
}
// StrutsHelloWorld.java
publicclassStrutsHelloWorldimplementsHelloWorld{
 
   @Override
   publicvoidsayHello(){
       System.out.println(“Struts Hello!”);
   }

}


// HelloProgram.java
publicclassHelloProgram {
   publicstaticvoidmain(String[] args){
       ApplicationContext context =
               new ClassPathXmlApplicationContext(“beans.xml”);
       HelloWorldService service =
            (HelloWorldService) context.getBean(“helloWorldService”);
       HelloWorld hw= service.getHelloWorld();
       hw.sayHello();
   }
}

// beans.xml
<beansxmlns=”http://http://www.springframework.org/schema/beans
                       http://www.springframework.org/schema/beans/spring-beans.xsd”>
 
   <beanid=“springHelloWorld”
       class=“com.spring.helloworld.impl.SpringHelloWorld”></bean>
   <beanid=“strutsHelloWorld”
       class=“com.spring.helloworld.impl.StrutsHelloWorld”></bean>
 
 
   <beanid=“helloWorldService”
       class=“com.spring.helloworld.HelloWorldService”>
       <propertyname=“helloWorld”ref=“springHelloWorld”/>
   </bean>
 
</beans>

<propertyname=“helloWorld”ref=“strutsHelloWorld”/>

ioc创建beans实现类springHelloWorld,创建一个helloWorldService类,beans.xml实现参数导入:

// helloWorldService
// springHelloWorld
// Hello Program.java
ApplicationContext context = new ClassPathXmlApplicationContxt(“beans.xml”);
HelloWorldService service = (HelloWorldService) context.getBean(“helloWorldService”);
HelloWorld hw = service.getHelloWorld();
hw.sayHello();

// HelloWorldService
publicclassHelloWorldService {
private HelloWorld helloWorld;
publicHelloWorldService(){
}
publicvoidsetHelloWorld(HelloWorld helloWorld){
 this.helloWorld = helloWorld;
}
public HelloWorld = getHelloWorld() {
 returnthis.helloWorld;
}

}

// beans.xml
<bean id=“名称”class=“路径”/>
<bean id=“helloWorldService”
class=“”>
<property name=“helloWorld”ref=“springHelloWorld”/>
</bean>

hello-world:
publicclassHelloWorld {
   private String name;
   publicvoidsetName(String name) {
       this.name = name;
   }
   publicvoidprintHello() {
       System.out.println(“Spring” + name);
   }
}

// xml
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd”>

   <beanid=“helloBean”class=“”>
       <propertyname=“name”value=“dashu” />
   </bean>

</beans>

// 执行
publicclassApp {
   publicstaticvoidmain(String[] args){
       ApplicationContext context = new ClassPathXmlApplicationContext(
               “applicationContext.xml”);
               HelloWorld obj = (HelloWorld) context.getBean(“helloBean”);
       obj.printHello();
   }

}

达叔小生:往后余生,唯独有你
You and me, we are family !
90 后帅气小伙,良好的开发习惯;独立思考的能力;主动并且善于沟通
简书博客: 达叔小生


丨极客文库, 版权所有丨如未注明 , 均为原创丨
本网站采用知识共享署名-非商业性使用-相同方式共享 3.0 中国大陆许可协议进行授权
转载请注明原文链接:Java 后端的学习之 Spring 基础
喜欢 (0)
[247507792@qq.com]
分享 (0)
勤劳的小蚂蚁
关于作者:
温馨提示:本文来源于网络,转载文章皆标明了出处,如果您发现侵权文章,请及时向站长反馈删除。

欢迎 注册账号 登录 发表评论!

  • 精品技术教程
  • 编程资源分享
  • 问答交流社区
  • 极客文库知识库

客服QQ


QQ:2248886839


工作时间:09:00-23:00