spring
优势：
方便解耦，简化开发；支持AOP编程（面向切面）；支持声明式事务；方便测试；方便集成各种优秀框架；降低javaEE API的使用难度；开源
spring程序开发步骤
-
maven导入spring开发的基本包坐标
<!--pom.xml文件--> <dependencies> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-context</artifactId> <version>5.3.16</version> </dependency> </dependencies> -
编写Dao接口和实现类
-
创建spring配置文件，配置userDaoImpl
<!--applicationContext.xml文件--> <bean id="userDao" class="com.lqr.Dao.Impl.UserDaoImpl"></bean> -
使用springAPI获得bean实例
ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");
UserDao userDao = (UserDao) app.getBean("userDao");
userDao.save();
spring配置文件
bean标签
用于配置对象交由spring创建，默认调用类中的无参构造
id为bean实例的唯一标识，class为bean的全限定名
scope为对象的作用范围
| 取值范围 | 说明 |
|---|---|
| singleton | 默认值，单例的，在加载applicationContext.xml时就调用无参构造创建了一个bean对象 |
| prototype | 多例的，调用getBean()方法才开始创建bean对象，对象长时间不使用会被GC回收 |
| request | WEB项目中，Spring创建一个 Bean的对象，将对象存入到request域中 |
| session | WEB项目中，Spring创建一个 Bean的对象，将对象存入到session域中 |
| global session | WEB项目中，应用在Portlet环境，如果没有Portlet环境，那么globalSession相当于session |
生命周期配置
<bean id="userDao" class="com.lqr.Dao.Impl.UserDaoImpl" init-method="init" destroy-method="destroy"></bean>
public class UserDaoImpl implements UserDao {
public UserDaoImpl(){
System.out.println("constructing userDaoImpl");
}
public void init(){
System.out.println("UserDaoImpl init method");
}
public void destroy(){
System.out.println("UserDaoImpl destroy method");
}
@Override
public void save() {
System.out.println("save running");
}
}
@Test
//测试scope属性
public void test1(){
ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");
UserDao userDao = (UserDao) app.getBean("userDao");
// UserDao userDao2 = (UserDao) app.getBean("userDao");
System.out.println(userDao);
// System.out.println(userDao2);
((ClassPathXmlApplicationContext)app).close();
}
如果不是手动关闭applicationContext，destroy方法来不及执行
bean实例化的三种方式
-
无参构造方法实例化
-
工厂静态方法实例化
<bean id="userDao" class="com.lqr.Factory.staticFactory" factory-method="getUserDao"></bean>public class staticFactory { public static UserDao getUserDao(){ return new UserDaoImpl() ; } } -
工厂实例方法实例化
<bean id="factory" class="com.lqr.Factory.DynamicFac" ></bean>
<bean id="userDao" factory-bean="factory" factory-method="getUserDao"></bean>
public class DynamicFac {
public UserDao getUserDao(){
return new UserDaoImpl() ;
}
}
依赖注入
通过控制反转，将对象的创建交给spring，业务层和持久层的依赖关系由spring维护，不用手动获取持久层对象
将DAO注入到Service内部的方法
-
构造方法
<bean id="userService" class="com.lqr.Service.Impl.UserServiceImpl"> <constructor-arg name="userDao" ref="userDao"></constructor-arg> </bean>public class UserServiceImpl implements UserService { private UserDao userDao; public UserServiceImpl(UserDao userDao) { this.userDao = userDao; } public UserServiceImpl() { } } -
set方法
<bean id="userService" class="com.lqr.Service.Impl.UserServiceImpl"> <property name="userDao" ref="userDao"></property> </bean> <!--p命名空间注入--> <bean id="userService" class="com.lqr.Service.Impl.UserServiceImpl" p:userDao-ref="userDao"></bean>public class UserServiceImpl implements UserService { private UserDao userDao; public void setUserDao(UserDao userDao) { this.userDao = userDao; } @Override public void save() { userDao.save(); } } public class UserController { public static void main(String[] args) { ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml"); UserServiceImpl userService = (UserServiceImpl) app.getBean("userService"); userService.save(); } }
依赖注入的数据类型
- 普通数据类型
- 引用数据类型
- 集合数据类型
import
在主配置文件中加载其他配置文件
<import resource="applicationContext-user.xml"/>
<import resource="applicationContext-product.xml"/>
spring相关API
applicationContext
接口类型，代表应用上下文，可以通过其实例获取spring容器中的bean对象
实现类
- classPathXmlApplicationContext：从类的根路径下加载配置文件
- fileSystemXmlApplicationContext：从磁盘路径上加载配置文件
- annotationConfigApplicationContext：使用注解配置容器对象时用来读取注解
getBean()
- 参数为bean配置对象时的id名，需要通过强制转化获得bean对象
- 参数为类.class，不需要强制转换
spring配置数据源
常见数据源(连接池)：DBCP、C3P0、BoneCP、Druid等
数据源开发步骤
-
导入数据源的坐标和数据库驱动坐标
<dependencies> <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <version>8.0.28</version> </dependency> <dependency> <groupId>c3p0</groupId> <artifactId>c3p0</artifactId> <version>0.9.1.2</version> </dependency> <dependency> <groupId>com.alibaba</groupId> <artifactId>druid</artifactId> <version>1.2.15</version> </dependency> <dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>4.12</version> <scope>test</scope> </dependency> </dependencies> -
设置数据源的基本连接数据
<!--jdbc.properties配置文件--> jdbc.driver=com.mysql.jdbc.Driver jdbc.url=jdbc:mysql://localhost:3306/test jdbc.username=root jdbc.password=root -
创建数据源对象
//c3p0 ResourceBundle rb = ResourceBundle.getBundle("jdbc");//读取配置文件 String driver = rb.getString("jdbc.driver"); String url = rb.getString("jdbc.url"); String username = rb.getString("jdbc.username"); String password = rb.getString("jdbc.password"); ComboPooledDataSource datasource = new ComboPooledDataSource(); datasource.setDriverClass(driver); datasource.setJdbcUrl(url); datasource.setUser(username); datasource.setPassword(password); -
获取资源和归还连接资源
Connection connection = datasource.getConnection(); connection.close();
spring配置数据源
将datasource的创建权交由spring容器完成
<!--applicationContext.xml-->
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
<property name="driverClass" value="com.mysql.jdbc.Driver"/>
<property name="jdbcUrl" value="jdbc:mysql://localhost:3306/test"/>
<property name="user" value="root"/>
<property name="password" value="root"/>
</bean>
抽取jdbc配置文件：
-
命名空间：
<beans ... xmlns:context="http://www.springframework.org/schema/context" xsi:schemaLocation="... http://www.springframework.org/schema/context http://www.springframework.org/shcema/context/spring-context.xsd" -
加载外部properties文件
<context:property-placeholder location="classpath:jdbc.properties"/> -
引用
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"> <property name="driverClass" value="${jdbc.driver}"/> <property name="jdbcUrl" value="${jdbc.url}"/> <property name="user" value="${jdbc.username}"/> <property name="password" value="${jdbc.password}"/> </bean>
spring注解开发
spring是轻代码重配置的框架，但配置繁重影响开发效率，注解代替xml配置文件可以简化配置，提高开发效率
spring原始注解
主要替代配置
- 配置组件扫描，指定哪个包下的bean需要进行扫描和识别使用注解配置：
<context:component-scan base-package="com.lqr"></context:component-scan>
- Dao的bean注解：
@Repository("userDao")
public class UserDaoImpl implements UserDao{}
- Service的bean注解：
@Service("userService")
public class UserServiceImpl implements UserService {
@Autowired//按照数据类型从spring容器中进行匹配
@Qualifier("userDao")//按照id名称从spring容器中进行匹配，需要结合Autowired使用
//@Resource(name="userDao")//相当于Autowired+Qualifier，需要导入包
private UserDao userDao;//不需要set方法和构造方法也能实现引用
}
xml配置的方法service中必须有set方法或构造方法来引用dao的bean，但注解方式不需要有
- 注解成员变量
@Value("${jdbc.driver}")//xml中配置了context:property-placeholder加载外部properties文件
private String driver;
新注解
原始注解无法解决的配置：
- 非自定义的bean配置
public class springConfig {
@Value("${jdbc.driver}")
private String driver;
@Bean("dataSource")
public DataSource getDataSource(){
ComboPooledDataSource dataSource = new ComboPooledDataSource();
dataSource.setDriverClass(driver);
return dataSource;
}
}
- 加载properties文件
@PropertySource("classpath:jdbc.properties")
- 组件扫描
@Configuration
@ComponentScan("com.lqr")
public class springConfig {}
- 引入其他配置文件
@Import({DataSourceConfig.class})
- controller加载配置类
ApplicationContext app = new AnnotationConfigApplicationContext(springConfig.class);
UserServiceImpl userService = (UserServiceImpl) app.getBean("userService");
userService.save();
spring集成Junit
-
导入spring集成junit坐标
<dependency> <groupId>org.springframework</groupId> <artifactId>spring-test</artifactId> <version>5.3.16</version> </dependency> -
使用@Runwith注解替换原来的运行期
-
使用@ContextConfiguration指定配置文件或配置类
-
使用@Autowired注入需要测试的对象
-
创建测试方法进行测试
@RunWith(SpringJUnit4ClassRunner.class)
//@ContextConfiguration("classpath:applicationContext.xml")//配置文件方式
@ContextConfiguration(classes = {springConfig.class})//全注解方式
public class springJunitTest {
@Autowired
private UserService userService;//配置文件方式时需要把component-scan配置好
@Test
public void test(){
userService.save();
}
}
spring集成web
环境搭建
-
maven依赖
<dependency> <groupId>javax.servlet</groupId> <artifactId>javax.servlet-api</artifactId> <version>3.0.1</version> <scope>provided</scope> </dependency> <dependency> <groupId>javax.servlet.jsp</groupId> <artifactId>javax.servlet.jsp-api</artifactId> <version>2.2.1</version> <scope>provided</scope> </dependency> -
web层
<!--web.xml--> <servlet> <servlet-name>userServlet</servlet-name> <servlet-class>com.lqr.web.UserServlet</servlet-class> </servlet> <servlet-mapping> <servlet-name>userServlet</servlet-name> <url-pattern>/userServlet</url-pattern> </servlet-mapping>public class UserServlet extends HttpServlet { @Override protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml"); UserService userServie = app.getBean(UserService.class); userServie.save(); } }
contextLoaderListener监听器
应用上下文通过new ClassPathXmlApplicationContext获取，每次从容器中获得bean都要编写，弊端是配置文件加载多次，上下文对象也要创建多次
在web项目中，可以使用servletContextListener监听web应用的启动，启动时加载spring配置文件，创建应用上下文对象，存储到最大的域servletContext域中，要用的时候从里面获取
-
web.xml配置监听器和spring配置文件
<listener> <listener-class>com.lqr.listener.contextListener</listener-class> </listener> <context-param> <param-name>contextConfigLocation</param-name> <param-value>applicationContext.xml</param-value> </context-param> -
监听器
public class contextListener implements ServletContextListener { @Override public void contextInitialized(ServletContextEvent servletContextEvent) { ServletContext servletContext = servletContextEvent.getServletContext(); String configLocation = servletContext.getInitParameter("contextConfigLocation"); ApplicationContext app = new ClassPathXmlApplicationContext(configLocation); servletContext.setAttribute("app", app); System.out.println("spring容器创建完毕。。。。。。。。"); } @Override public void contextDestroyed(ServletContextEvent servletContextEvent) { } } -
servlet获取上下文
public class UserServlet extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
ServletContext servletContext = req.getServletContext();
ApplicationContext app = (ApplicationContext) servletContext.getAttribute("app");
UserService userServie = app.getBean(UserService.class);
userServie.save();
}
}
未访问servlet时spring容器就被创建好了，访问时再去取
spring提供的上述功能的监听器——contextLoaderListener
-
导入spring-web坐标
<dependency> <groupId>org.springframework</groupId> <artifactId>spring-web</artifactId> <version>5.3.16</version> </dependency> -
web.xml配置监听器
<listener> <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class> </listener> <context-param> <param-name>contextConfigLocation</param-name> <param-value>classpath:applicationContext.xml</param-value> </context-param> -
使用webApplicationContextUtils获得应用上下文对象
public class UserServlet extends HttpServlet { @Override protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { ServletContext servletContext = req.getServletContext(); ApplicationContext app = WebApplicationContextUtils.getWebApplicationContext(servletContext); UserService userServie = app.getBean(UserService.class); userServie.save(); } }
springMVC
开发步骤
-
导入SpringMVC包，springMVC充当前端控制器
<!--pom.xml--> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-webmvc</artifactId> <version>5.3.16</version> </dependency> -
配置servlet，指定spring-mvc配置文件
<!--web.xml--> <servlet> <servlet-name>DispatcherServlet</servlet-name> <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class> <init-param> <param-name>contextConfigLocation</param-name> <param-value>classpath:spring-mvc.xml</param-value> </init-param> <load-on-startup>1</load-on-startup> </servlet> <servlet-mapping> <servlet-name>DispatcherServlet</servlet-name> <url-pattern>/</url-pattern> </servlet-mapping> -
编写controller，将controller使用注解配置到spring容器中（@controller）
@Controller public class userController { @RequestMapping("/save") public String save(){ System.out.println("usercontroller save running...."); return "success.jsp"; } } -
配置spring-mvc.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:context="http://www.springframework.org/schema/context" 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"> <context:component-scan base-package="com.lqr.controller"/> </beans> -
执行访问测试
springMVC组件解析
springMVC执行流程
springMVC注解解析
@RequestMapping：建立URL和请求方法之间的映射，可以放在类上或方法上
属性：value(指定URL)，method(指定请求方式)，params(限制请求参数)
springMVC组件扫描
- 引入mvc和context命名空间
- springMVC基于spring容器，需要将controller存储到spring容器中，使用
<context:component-scan base-package="xxx.controller"/>进行扫描
springMVC的xml配置
除组件扫描配置外，还可以手动配置内部资源解析器：
<bean id="viewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<property name="prefix" value="/jsp/"></property>
<property name="suffix" value=".jsp"></property>
</bean>
@Controller
@RequestMapping("/user")
public class userController {
@RequestMapping("/save")
public String save(){
System.out.println("usercontroller save running....");
return "success";//省略了前后缀
}
}
springMVC数据响应
数据响应方式
页面跳转
-
直接返回字符串：将返回的字符串和视图解析器的前后缀拼接后跳转
-
通过modelAndView对象返回
@RequestMapping("/save2")
public ModelAndView save2(){
/**
* model:模型，用于封装数据
* view：视图，用于展示数据
*/
ModelAndView modelAndView = new ModelAndView();
modelAndView.addObject("username","lqr");
modelAndView.setViewName("success");
return modelAndView;
}
@RequestMapping("/save3")
public ModelAndView save3(ModelAndView modelAndView){//springMVC会自动注入参数
modelAndView.addObject("username","modelAndView test 2");
modelAndView.setViewName("success");
return modelAndView;
}
@RequestMapping("/save4")
public String save4(Model model){
model.addAttribute("username", "mode test");
return "success";
}
@RequestMapping("/save5")
public String save5(HttpServletRequest request){//不常用
request.setAttribute("username","http request");
return "success";
}
<html>
<head>
<title>success</title>
</head>
<body>
<h1>Success, ${username}</h1>
</body>
</html>
回写数据
-
直接返回字符串
@RequestMapping("/send") public void send(HttpServletResponse response) throws IOException { response.getWriter().print("hello world, this is response send test"); } @RequestMapping("/send2") @ResponseBody//告知springMVC不是进行页面跳转，而是返回字符串 public String send2(){ return "hello world, this is send2 test"; }返回json格式的字符串（需要导入包）
<dependency> <groupId>com.fasterxml.jackson.core</groupId> <artifactId>jackson-core</artifactId> <version>2.13.1</version> </dependency> <dependency> <groupId>com.fasterxml.jackson.core</groupId> <artifactId>jackson-databind</artifactId> <version>2.13.1</version> </dependency> <dependency> <groupId>com.fasterxml.jackson.core</groupId> <artifactId>jackson-annotations</artifactId> <version>2.13.1</version> </dependency>@RequestMapping("/send3") @ResponseBody public String send3() throws JsonProcessingException { User user= new User("lqr", 22);//user必须要有set和get方法，否则会报错 ObjectMapper objectMapper = new ObjectMapper(); String json = objectMapper.writeValueAsString(user); return json; } -
返回对象或集合
<!--配置处理器映射器，将转换器设置为json转换--> <bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter"> <property name="messageConverters"> <list> <bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter"/> </list> </property> </bean>@RequestMapping("/send4") @ResponseBody public User send4(){ User user= new User("lqr", 22); return user; }使用mvc注解驱动可以代替@ResponseBody注解
springMVC中，处理器映射器、处理器适配器、视图解析器称为三大组件，mvc:annotation-driven自动加载RequestMappingHandlerMapping和RequestMappingHandlerAdapter，代替注解处理器和适配器的配置，默认底层集成jackson进行对象或集合的json字符串转换
63万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
