快速上手:
创建Student类
package com.nhooo;
public class Student {
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public void displayInfo(){
System.out.println("Hello: "+name);
}
}
创建applicationContext.xml 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"
xmlns:p="http://www.springframework.org/schema/p"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
<bean id="studentbean" class="com.nhooo.Student">
<property name="name" value="Vimal Jaiswal"></property>
</bean>
</beans>
bean 元素用于为给定类定义bean。 bean的 property 子元素指定名为name的Student类的属性。属性元素中指定的值将由IOC容器在Student类对象中设置。
获取Student对象并打印
package com.nhooo;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.core.io.ClassPathResource;
import org.springframework.core.io.Resource;
public class Test {
public static void main(String[] args) {
Resource resource=new ClassPathResource("applicationContext.xml");
BeanFactory factory=new XmlBeanFactory(resource);
Student student=(Student)factory.getBean("studentbean");
student.displayInfo();
}
}
Spring原理
Spring 是轻量级的开源javaEE框架 简化企业应用开发复杂性 本质上是工厂模式:在service和dao层之间加上BeanFactory类 用来创建dao对象 供services使用
IOC容器
IoC容器负责实例化,配置和组装对象。 IoC容器从XML文件获取信息并相应地工作。 IoC容器执行的主要任务是:
实例化应用程序类配置对象组装对象之间的依赖关系
IOC容器有两个类型
BeanFactory --org.springframework.beans.factory
Resource resource=new ClassPathResource("applicationContext.xml");
BeanFactory factory=new XmlBeanFactory(resource);
ApplicationContext --org.springframework.context
ApplicationContext context =
new ClassPathXmlApplicationContext("applicationContext.xml");
ApplicationContext 接口充当IoC容器。 ApplicationContext接口建立在BeanFactory接口的顶部。它比BeanFactory增加了一些额外的功能,例如与Spring的AOP的简单集成,消息资源处理(用于I18N),事件传播,Web应用程序的特定于应用程序层的上下文(例如WebApplicationContext)。因此,使用ApplicationContext比使用BeanFactory更好
IOC管理bean的两种方式
Spring依赖注入(构造函数或setter)
依赖注入是一种设计模式,它消除了程式。在这种情况下,我们提供来自外部源(例如XML文件)的信息。它使我们的代码松散耦合,并且更易于测试
通常设计对象时 提供外部赋值功能 代码如下:
class Employee{
Address address;
Employee(Address address){
this.address=address;
}
public void setAddress(Address address){
this.address=address;
}
}
在这种情况下,Address类的实例由外部源(例如XML文件)通过构造函数或setter方法提供。
通过构造器注入的方式
int注入
<bean id="e" class="com.nhooo.Employee">
<constructor-arg value="10" type="int"></constructor-arg>
</bean>
String注入
<bean id="e" class="com.nhooo.Employee">
<constructor-arg value="10"></constructor-arg>
</bean>
对象注入 ref
<bean id="a1" class="com.nhooo.Address">
<constructor-arg value="ghaziabad"></constructor-arg>
<constructor-arg value="UP"></constructor-arg>
<constructor-arg value="India"></constructor-arg>
</bean>
<!--注入a1对象到e中-->
<bean id="e" class="com.nhooo.Employee">
<constructor-arg value="12" type="int"></constructor-arg>
<constructor-arg value="Sonoo"></constructor-arg>
<constructor-arg>
<ref bean="a1"/>
</constructor-arg>
</bean>
list注入
<constructor-arg>
<list>
<value>Java is a programming language</value>
<value>Java is a Platform</value>
<value>Java is an Island of Indonasia</value>
</list>
</constructor-arg>
<!--注入的元素中含有对象的注入-->
<constructor-arg>
<list>
<ref bean="ans1"/>
<ref bean="ans2"/>
</list>
</constructor-arg>
Map注入
<constructor-arg>
<map>
<entry key="Java is a Programming Language" value="Ajay Kumar"></entry>
<entry key="Java is a Platform" value="John Smith"></entry>
<entry key="Java is an Island" value="Raj Kumar"></entry>
</map>
</constructor-arg>
<!--注入的元素中含有对象的注入-->
<constructor-arg>
<map>
<entry key-ref="answer1" value-ref="user1"></entry>
<entry key-ref="answer2" value-ref="user2"></entry>
</map>
</constructor-arg>
通过SETTER方法注入的方式
int、String注入
<bean id="obj" class="com.nhooo.Employee">
<property name="id">
<value>20</value>
</property>
<property name="name">
<value>Arun</value>
</property>
<property name="city">
<value>ghaziabad</value>
</property>
</bean>
对象注入
其中ref属性时 对另一个bean的应用
<property name="address" ref="address1"></property>
List注入
<property name="answers">
<list>
<value>Java is a programming language</value>
<value>Java is a platform</value>
<value>Java is an Island</value>
</list>
Spring自动装配
byName自动装配模式
在byName自动装配模式下,bean id和引用名称必须相同。b = org.sssit.B
<bean id="b" class="org.sssit.B"></bean>
<bean id="a" class="org.sssit.A" autowire="byName"></bean>
byType自动装配模式
bean ID和引用名称可能不同。但是只能有一个类型的bean。
<bean id="b1" class="org.sssit.B"></bean>
<bean id="a" class="org.sssit.A" autowire="byType"></bean>
在这种情况下,它可以正常工作,因为您创建了B类型的实例。没关系,您可以使用与引用名称不同的Bean名称。
但是,如果您具有一种类型的多个Bean,它将不起作用并抛出异常。
构造函数自动装配模式
如果一个类中的3个构造函数,零参数,一个参数和两个参数,然后通过调用两个参数构造函数执行注入。
<bean id="b" class="org.sssit.B"></bean>
<bean id="a" class="org.sssit.A" autowire="constructor"></bean>
没有自动装配模式
<bean id="b" class="org.sssit.B"></bean>
<bean id="a" class="org.sssit.A" autowire="no"></bean>
在没有自动装配模式的情况下,spring容器不会通过自动装配注入依赖项。
Spring jdbcTemplete
旧JDBC API的问题:
操作繁琐 :创建链接 SQL语句 关闭结果集。
我们需要在数据库逻辑上执行异常处理代码。我们需要处理交易。
将所有这些代码从一个数据库逻辑重复到另一个数据库逻辑是一项耗时的工作。
而Spring JdbcTemplate消除了上述JDBC API的所有问题。它提供了直接编写查询的方法,从而节省了大量的工作和时间。
JdbcTemplate类 负责创建和释放资源 例如创建和关闭连接对象等 如果忘记关闭连接也不会导致任何问题
dbcTemplate类提供的方法:
方法名 | 说明 |
public int update(String query) | 用于插入,更新和删除记录。 |
public int update(String query,Object ... args) | 用于通过使用给定参数的PreparedStatement插入,更新和删除记录。 |
public void execute(String query) | 用于执行DDL查询。 |
public T execute(String sql, PreparedStatementCallback action) | 通过使用PreparedStatement回调执行查询。 |
public T query(String sql, ResultSetExtractor rse) | 用于使用ResultSetExtractor获取记录。 |
public List query(String sql, RowMapper rse) | 用于使用RowMapper获取记录。 |
代码示例
package com.nhooo;
import org.springframework.jdbc.core.JdbcTemplate;
public class EmployeeDao {
private JdbcTemplate jdbcTemplate;
public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
this.jdbcTemplate = jdbcTemplate;
}
public int saveEmployee(Employee e){
String query="insert into employee values( '"+e.getId()+"','"+e.getName()+"','"+e.getSalary()+"')";
return jdbcTemplate.update(query);
}
public int updateEmployee(Employee e){
String query="update employee set
name='"+e.getName()+"',salary='"+e.getSalary()+"' where id='"+e.getId()+"' ";
return jdbcTemplate.update(query);
}
public int deleteEmployee(Employee e){
String query="delete from employee where id='"+e.getId()+"' ";
return jdbcTemplate.update(query);
}
}
<?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:p="http://www.springframework.org/schema/p"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
<!--DriverManagerDataSource 用于包含有关数据库的信息,例如驱动程序类名称,连接URL,用户名和密码。-->
<bean id="ds" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="driverClassName" value="oracle.jdbc.driver.OracleDriver" />
<property name="url" value="jdbc:oracle:thin:@localhost:1521:xe" />
<property name="username" value="system" />
<property name="password" value="oracle" />
</bean>
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
<property name="dataSource" ref="ds"></property>
</bean>
<bean id="edao" class="com.nhooo.EmployeeDao">
<property name="jdbcTemplate" ref="jdbcTemplate"></property>
</bean>
</beans>
获取bean
ApplicationContext ctx=new ClassPathXmlApplicationContext("applicationContext.xml");
EmployeeDao dao=(EmployeeDao)ctx.getBean("edao");
int status=dao.saveEmployee(new Employee(102,"Amit",35000));
System.out.println(status);
/*int status=dao.updateEmployee(new Employee(102,"Sonoo",15000));
System.out.println(status);
*/
/*Employee e=new Employee();
e.setId(102);
int status=dao.deleteEmployee(e);
System.out.println(status);*/
Spring ORM框架
什么是ORM
即Object Relational Mapping,它是对象关系模型的简称。它的作用是在关系型数据库和对象之间作一个映射。使程序能够通过操纵描述对象方式来操纵数据库。
ORM解决的主要问题是对象关系的映射,一般情况下,一个持久化类和一个表对应,类的每个实例对应表中的一条记录,类的每个属性对应表的每个字段。 ## ORM技术特点:
提高了开发效率。由于ORM可以自动对Entity对象与数据库中的Table进行字段与属性的映射,所以我们实际可能已经不需要一个专用的、庞大的数据访问层。
ORM提供了对数据库的映射,不用sql直接编码,能够像操作对象一样从数据库获取数据。
Spring如何集成ORM
市面上主流的ORM框架有 Hibernate和mybatis
Spring MVC
它遵循Model-View-Controller设计模式。它实现了核心Spring框架的所有基本功能,例如控制反转,依赖注入。
SpringMVC流程和原理
所有的requestid都会被DispatcherServlet拦截
拦截后DispatcherServlet会从web.xml文件中获取处理映射的条目 并将request转发到控制器
控制器返回modelandview对象
SpringMVC框架示例
![](https://i-blog.csdnimg.cn/blog_migrate/575b73539b753a526fcb8e7f6da4d73b.png)
在pom.xml文件中提供项目信息和配置。
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.nhooo</groupId>
<artifactId>SpringMVC</artifactId>
<packaging>war</packaging>
<version>0.0.1-SNAPSHOT</version>
<name>SpringMVC Maven Webapp</name>
<url>http://maven.apache.org</url>
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>3.8.1</version>
<scope>test</scope>
</dependency>
<!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>5.1.1.RELEASE</version>
</dependency>
<!-- https://mvnrepository.com/artifact/javax.servlet/javax.servlet-api -->
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>servlet-api</artifactId>
<version>3.0-alpha-1</version>
</dependency>
</dependencies>
<build>
<finalName>SpringMVC</finalName>
</build>
</project>
创建controller控制类
要创建控制器类,我们使用两个注释@Controller和@RequestMapping。
@Controller注释将该类标记为Controller。
@Requestmapping批注用于映射具有指定URL名称的类。
package com.nhooo;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
@Controller
public class HelloController {
@RequestMapping("/")
public String display()
{
return "index";
}
}
在web.xml文件中提供控制器的条目
在此web.xml文件中,我们指定Servlet类DispatcherServlet充当Spring Web MVC中的前端控制器。 html文件的所有传入请求都将转发到DispatcherServlet。
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd" id="WebApp_ID" version="3.0">
<display-name>SpringMVC</display-name>
<servlet>
<servlet-name>spring</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>spring</servlet-name>
<url-pattern>/</url-pattern>
</servlet-mapping>
</web-app>
在xml文件中定义bean。
这是重要的配置文件,需要在其中指定View组件。
context: component-scan元素定义了DispatcherServlet的基本包。将搜索控制器类。
此xml文件应位于WEB-INF目录内。
<?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:context="http://www.springframework.org/schema/context"
xmlns:mvc="http://www.springframework.org/schema/mvc"
xsi:schemaLocation="
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/mvc
http://www.springframework.org/schema/mvc/spring-mvc.xsd">
<!-- Provide support for component scanning -->
<context:component-scan base-package="com.nhooo" />
<!--Provide support for conversion, formatting and validation -->
<mvc:annotation-driven/>
</beans>
在JSP页面中显示消息
index.jsp
<html>
<body>
<p>Welcome to Spring MVC Tutorial</p>
</body>
</html>