/usr/share/doc/libatinject-jsr330-api-java/api/javax/inject/package-summary.html is in libatinject-jsr330-api-java-doc 1.0+ds1-5.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 | <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<!-- NewPage -->
<html>
<head>
<title>javax.inject (JSR 330: Dependency Injection for Java)</title>
<meta name="date" content="2017-11-17">
<link rel="stylesheet" type="text/css" href="../../stylesheet.css" title="Style">
<script type="text/javascript" src="../../script.js"></script>
</head>
<body>
<script type="text/javascript"><!--
try {
if (location.href.indexOf('is-external=true') == -1) {
parent.document.title="javax.inject (JSR 330: Dependency Injection for Java)";
}
}
catch(err) {
}
//-->
</script>
<noscript>
<div>JavaScript is disabled on your browser.</div>
</noscript>
<!-- ========= START OF TOP NAVBAR ======= -->
<div class="topNav"><a name="navbar.top">
<!-- -->
</a>
<div class="skipNav"><a href="#skip.navbar.top" title="Skip navigation links">Skip navigation links</a></div>
<a name="navbar.top.firstrow">
<!-- -->
</a>
<ul class="navList" title="Navigation">
<li><a href="../../overview-summary.html">Overview</a></li>
<li class="navBarCell1Rev">Package</li>
<li>Class</li>
<li><a href="package-tree.html">Tree</a></li>
<li><a href="../../deprecated-list.html">Deprecated</a></li>
<li><a href="../../index-all.html">Index</a></li>
<li><a href="../../help-doc.html">Help</a></li>
</ul>
</div>
<div class="subNav">
<ul class="navList">
<li>Prev Package</li>
<li><a href="../../org/atinject/tck/package-summary.html">Next Package</a></li>
</ul>
<ul class="navList">
<li><a href="../../index.html?javax/inject/package-summary.html" target="_top">Frames</a></li>
<li><a href="package-summary.html" target="_top">No Frames</a></li>
</ul>
<ul class="navList" id="allclasses_navbar_top">
<li><a href="../../allclasses-noframe.html">All Classes</a></li>
</ul>
<div>
<script type="text/javascript"><!--
allClassesLink = document.getElementById("allclasses_navbar_top");
if(window==top) {
allClassesLink.style.display = "block";
}
else {
allClassesLink.style.display = "none";
}
//-->
</script>
</div>
<a name="skip.navbar.top">
<!-- -->
</a></div>
<!-- ========= END OF TOP NAVBAR ========= -->
<div class="header">
<h1 title="Package" class="title">Package javax.inject</h1>
<div class="docSummary">
<div class="block">This package specifies a means for obtaining objects in such a way as to
maximize reusability, testability and maintainability compared to
traditional approaches such as constructors, factories, and service
locators (e.g., JNDI). This process, known as <i>dependency
injection</i>, is beneficial to most nontrivial applications.</div>
</div>
<p>See: <a href="#package.description">Description</a></p>
</div>
<div class="contentContainer">
<ul class="blockList">
<li class="blockList">
<table class="typeSummary" border="0" cellpadding="3" cellspacing="0" summary="Interface Summary table, listing interfaces, and an explanation">
<caption><span>Interface Summary</span><span class="tabEnd"> </span></caption>
<tr>
<th class="colFirst" scope="col">Interface</th>
<th class="colLast" scope="col">Description</th>
</tr>
<tbody>
<tr class="altColor">
<td class="colFirst"><a href="../../javax/inject/Provider.html" title="interface in javax.inject">Provider</a><T></td>
<td class="colLast">
<div class="block">Provides instances of <code>T</code>.</div>
</td>
</tr>
</tbody>
</table>
</li>
<li class="blockList">
<table class="typeSummary" border="0" cellpadding="3" cellspacing="0" summary="Annotation Types Summary table, listing annotation types, and an explanation">
<caption><span>Annotation Types Summary</span><span class="tabEnd"> </span></caption>
<tr>
<th class="colFirst" scope="col">Annotation Type</th>
<th class="colLast" scope="col">Description</th>
</tr>
<tbody>
<tr class="altColor">
<td class="colFirst"><a href="../../javax/inject/Inject.html" title="annotation in javax.inject">Inject</a></td>
<td class="colLast">
<div class="block">Identifies injectable constructors, methods, and fields.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><a href="../../javax/inject/Named.html" title="annotation in javax.inject">Named</a></td>
<td class="colLast">
<div class="block">String-based <a href="../../javax/inject/Qualifier.html" title="annotation in javax.inject">qualifier</a>.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><a href="../../javax/inject/Qualifier.html" title="annotation in javax.inject">Qualifier</a></td>
<td class="colLast">
<div class="block">Identifies qualifier annotations.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><a href="../../javax/inject/Scope.html" title="annotation in javax.inject">Scope</a></td>
<td class="colLast">
<div class="block">Identifies scope annotations.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><a href="../../javax/inject/Singleton.html" title="annotation in javax.inject">Singleton</a></td>
<td class="colLast">
<div class="block">Identifies a type that the injector only instantiates once.</div>
</td>
</tr>
</tbody>
</table>
</li>
</ul>
<a name="package.description">
<!-- -->
</a>
<h2 title="Package javax.inject Description">Package javax.inject Description</h2>
<div class="block">This package specifies a means for obtaining objects in such a way as to
maximize reusability, testability and maintainability compared to
traditional approaches such as constructors, factories, and service
locators (e.g., JNDI). This process, known as <i>dependency
injection</i>, is beneficial to most nontrivial applications.
<p>Many types depend on other types. For example, a <tt>Stopwatch</tt> might
depend on a <tt>TimeSource</tt>. The types on which a type depends are
known as its <i>dependencies</i>. The process of finding an instance of a
dependency to use at run time is known as <i>resolving</i> the dependency.
If no such instance can be found, the dependency is said to be
<i>unsatisfied</i>, and the application is broken.
<p>In the absence of dependency injection, an object can resolve its
dependencies in a few ways. It can invoke a constructor, hard-wiring an
object directly to its dependency's implementation and life cycle:
<pre> class Stopwatch {
final TimeSource timeSource;
Stopwatch () {
timeSource = <b>new AtomicClock(...)</b>;
}
void start() { ... }
long stop() { ... }
}</pre>
<p>If more flexibility is needed, the object can call out to a factory or
service locator:
<pre> class Stopwatch {
final TimeSource timeSource;
Stopwatch () {
timeSource = <b>DefaultTimeSource.getInstance()</b>;
}
void start() { ... }
long stop() { ... }
}</pre>
<p>In deciding between these traditional approaches to dependency
resolution, a programmer must make trade-offs. Constructors are more
concise but restrictive. Factories decouple the client and implementation
to some extent but require boilerplate code. Service locators decouple even
further but reduce compile time type safety. All three approaches inhibit
unit testing. For example, if the programmer uses a factory, each test
against code that depends on the factory will have to mock out the factory
and remember to clean up after itself or else risk side effects:
<pre> void testStopwatch() {
<b>TimeSource original = DefaultTimeSource.getInstance();
DefaultTimeSource.setInstance(new MockTimeSource());
try {</b>
// Now, we can actually test Stopwatch.
Stopwatch sw = new Stopwatch();
...
<b>} finally {
DefaultTimeSource.setInstance(original);
}</b>
}</pre>
<p>In practice, supporting this ability to mock out a factory results in
even more boilerplate code. Tests that mock out and clean up after multiple
dependencies quickly get out of hand. To make matters worse, a programmer
must predict accurately how much flexibility will be needed in the future
or else suffer the consequences. If a programmer initially elects to use a
constructor but later decides that more flexibility is required, the
programmer must replace every call to the constructor. If the programmer
errs on the side of caution and write factories up front, it may result in
a lot of unnecessary boilerplate code, adding noise, complexity, and
error-proneness.
<p><i>Dependency injection</i> addresses all of these issues. Instead of
the programmer calling a constructor or factory, a tool called a
<i>dependency injector</i> passes dependencies to objects:
<pre> class Stopwatch {
final TimeSource timeSource;
<b>@Inject Stopwatch(TimeSource timeSource)</b> {
this.timeSource = timeSource;
}
void start() { ... }
long stop() { ... }
}</pre>
<p>The injector further passes dependencies to other dependencies until it
constructs the entire object graph. For example, suppose the programmer
asked an injector to create a <tt>StopwatchWidget</tt> instance:
<pre> /** GUI for a Stopwatch */
class StopwatchWidget {
@Inject StopwatchWidget(Stopwatch sw) { ... }
...
}</pre>
<p>The injector might:
<ol>
<li>Find a <tt>TimeSource</tt>
<li>Construct a <tt>Stopwatch</tt> with the <tt>TimeSource</tt>
<li>Construct a <tt>StopwatchWidget</tt> with the <tt>Stopwatch</tt>
</ol>
<p>This leaves the programmer's code clean, flexible, and relatively free
of dependency-related infrastructure.
<p>In unit tests, the programmer can now construct objects directly
(without an injector) and pass in mock dependencies. The programmer no
longer needs to set up and tear down factories or service locators in each
test. This greatly simplifies our unit test:
<pre> void testStopwatch() {
Stopwatch sw = new Stopwatch(new MockTimeSource());
...
}</pre>
<p>The total decrease in unit-test complexity is proportional to the
product of the number of unit tests and the number of dependencies.
<p><b>This package provides dependency injection annotations that enable
portable classes</b>, but it leaves external dependency configuration up to
the injector implementation. Programmers annotate constructors, methods,
and fields to advertise their injectability (constructor injection is
demonstrated in the examples above). A dependency injector identifies a
class's dependencies by inspecting these annotations, and injects the
dependencies at run time. Moreover, the injector can verify that all
dependencies have been satisfied at <i>build time</i>. A service locator,
by contrast, cannot detect unsatisfied dependencies until run time.
<p>Injector implementations can take many forms. An injector could
configure itself using XML, annotations, a DSL (domain-specific language),
or even plain Java code. An injector could rely on reflection or code
generation. An injector that uses compile-time code generation may not even
have its own run time representation. Other injectors may not be able to
generate code at all, neither at compile nor run time. A "container", for
some definition, can be an injector, but this package specification aims to
minimize restrictions on injector implementations.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../javax/inject/Inject.html" title="annotation in javax.inject"><code>@Inject</code></a></dd>
</dl>
</div>
<!-- ======= START OF BOTTOM NAVBAR ====== -->
<div class="bottomNav"><a name="navbar.bottom">
<!-- -->
</a>
<div class="skipNav"><a href="#skip.navbar.bottom" title="Skip navigation links">Skip navigation links</a></div>
<a name="navbar.bottom.firstrow">
<!-- -->
</a>
<ul class="navList" title="Navigation">
<li><a href="../../overview-summary.html">Overview</a></li>
<li class="navBarCell1Rev">Package</li>
<li>Class</li>
<li><a href="package-tree.html">Tree</a></li>
<li><a href="../../deprecated-list.html">Deprecated</a></li>
<li><a href="../../index-all.html">Index</a></li>
<li><a href="../../help-doc.html">Help</a></li>
</ul>
</div>
<div class="subNav">
<ul class="navList">
<li>Prev Package</li>
<li><a href="../../org/atinject/tck/package-summary.html">Next Package</a></li>
</ul>
<ul class="navList">
<li><a href="../../index.html?javax/inject/package-summary.html" target="_top">Frames</a></li>
<li><a href="package-summary.html" target="_top">No Frames</a></li>
</ul>
<ul class="navList" id="allclasses_navbar_bottom">
<li><a href="../../allclasses-noframe.html">All Classes</a></li>
</ul>
<div>
<script type="text/javascript"><!--
allClassesLink = document.getElementById("allclasses_navbar_bottom");
if(window==top) {
allClassesLink.style.display = "block";
}
else {
allClassesLink.style.display = "none";
}
//-->
</script>
</div>
<a name="skip.navbar.bottom">
<!-- -->
</a></div>
<!-- ======== END OF BOTTOM NAVBAR ======= -->
</body>
</html>
|